Java StringUtils.makeRandomString方法代码示例

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getAndSetGlobalParam() throws Exception {
  final String key = StringUtils.makeRandomString(5);
  final String value = StringUtils.makeRandomString(5);
  AbstractScriptStep setStep = new AbstractScriptStep(StringUtils.makeRandomString(5)) {
    @Override
    public void runStep() {
      setGlobalParam(key, value);
    }
  };
  AbstractScriptStep verifyStep = new AbstractScriptStep(StringUtils.makeRandomString(5)) {
    @Override
    public void runStep() {
      assertEquals(value, getGlobalParam(key));
    }
  };
  
  setStep.runStep();
  verifyStep.runStep();
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getQueuedTaskCountTest() {
  // must be single thread scheduler so we can block one on the shceduler
  KeyedSchedulerServiceLimiter limiter = new KeyedSchedulerServiceLimiter(new SingleThreadScheduler(), 1);
  String key = StringUtils.makeRandomString(5);
  
  BlockingTestRunnable btr = new BlockingTestRunnable();
  try {
    assertEquals(0, limiter.getQueuedTaskCount());
    
    limiter.execute(key, btr);
    btr.blockTillStarted();
    
    limiter.execute(StringUtils.makeRandomString(2), DoNothingRunnable.instance());
    // 1 blocked on scheduler due to different key
    assertEquals(1, limiter.getQueuedTaskCount());
    

    limiter.execute(key, DoNothingRunnable.instance());
    // 1 additional blocked in limiter now
    assertEquals(2, limiter.getQueuedTaskCount());
  } finally {
    btr.unblock();
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void throwMapAlreadyDoneTest() throws InterruptedException, ExecutionException {
  String sourceObject = StringUtils.makeRandomString(5);
  ListenableFuture<String> lf = makeListenableFutureFactory().makeWithResult(sourceObject);
  String translatedObject = StringUtils.makeRandomString(10);
  ListenableFuture<String> mappedLF = lf.throwMap((s) -> {
    if (s == sourceObject) {
      return translatedObject;
    } else {
      // test failure
      return null;
    }
  });
  
  assertTrue(mappedLF.isDone());
  assertTrue(translatedObject == mappedLF.get());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getUnsubmittedTaskCountMapTest() {
  AbstractKeyedLimiter<?> singleConcurrencyLimiter = makeLimiter(1);
  String key = StringUtils.makeRandomString(5);
  BlockingTestRunnable btr = new BlockingTestRunnable();
  try {
    assertTrue(singleConcurrencyLimiter.getUnsubmittedTaskCountMap().isEmpty());
    singleConcurrencyLimiter.execute(key, btr);
    btr.blockTillStarted();

    // should not be queued any more
    assertTrue(singleConcurrencyLimiter.getUnsubmittedTaskCountMap().isEmpty());
    
    for (int i = 1; i < TEST_QTY; i++) {
      singleConcurrencyLimiter.submit(key, DoNothingRunnable.instance());
      Map<?, ?> taskCountMap = singleConcurrencyLimiter.getUnsubmittedTaskCountMap();
      assertEquals(1, taskCountMap.size());
      assertEquals(i, taskCountMap.get(key));
    }
  } finally {
    btr.unblock();
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void renamePrependAndResetTest() {
  final String originalName = Thread.currentThread().getName();
  final String newName = StringUtils.makeRandomString(5);
  
  TestRunnable tr = new TestRunnable() {
    @Override
    public void handleRunStart() {
      assertTrue(Thread.currentThread().getName().startsWith(newName));
      assertTrue(Thread.currentThread().getName().contains(originalName));
    }
  };

  assertEquals(originalName, Thread.currentThread().getName());
  
  new ThreadRenamingRunnable(tr, newName, false).run();
  
  assertTrue(tr.ranOnce());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void removeCallableTest() {
  KeyedSchedulerServiceLimiter limiter = makeLimiter(1);
  String key = StringUtils.makeRandomString(5);
  
  BlockingTestRunnable btr = new BlockingTestRunnable();
  try {
    assertFalse(limiter.remove(btr));
    assertFalse(limiter.remove((Runnable)null));
    
    limiter.execute(key, btr);
    
    TestCallable tc = new TestCallable();
    
    assertFalse(limiter.remove(tc));

    limiter.submit(key, tc);
    assertTrue(limiter.remove(tc));
    assertFalse(limiter.remove(tc));
  } finally {
    btr.unblock();
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void renameReplaceAndResetTest() {
  final String originalName = Thread.currentThread().getName();
  final String newName = StringUtils.makeRandomString(5);
  
  TestRunnable tr = new TestRunnable() {
    @Override
    public void handleRunStart() {
      assertEquals(newName, Thread.currentThread().getName());
    }
  };

  assertEquals(originalName, Thread.currentThread().getName());
  
  new ThreadRenamingRunnable(tr, newName, true).run();
  
  assertTrue(tr.ranOnce());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getWithTimeoutResultTest() throws InterruptedException, 
                                              ExecutionException, 
                                              TimeoutException {
  final String testResult = StringUtils.makeRandomString(5);
  
  PriorityScheduler scheduler = new StrictPriorityScheduler(1);
  try {
    scheduler.prestartAllThreads();
    scheduler.schedule(new Runnable() {
      @Override
      public void run() {
        slf.setResult(testResult);
      }
    }, DELAY_TIME);
    
    assertTrue(slf.get(DELAY_TIME + (SLOW_MACHINE ? 2000 : 1000), TimeUnit.MILLISECONDS) == testResult);
  } finally {
    scheduler.shutdownNow();
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void increaseMaxConcurrencyTest() {
  AbstractKeyedLimiter<?> limiter = makeLimiter(1);
  String key = StringUtils.makeRandomString(5);
  
  BlockingTestRunnable btr = new BlockingTestRunnable();
  try {
    limiter.execute(key, btr);
    // block till started so that our entire limit is used up
    btr.blockTillStarted();
    
    TestRunnable tr = new TestRunnable();
    limiter.execute(key, tr);  // wont be able to run
    
    limiter.setMaxConcurrencyPerKey(2);
    
    tr.blockTillFinished();  // should be able to complete now that limit was increased
  } finally {
    btr.unblock();
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void flatMapWithExecutorAlreadyDoneTest() throws InterruptedException, ExecutionException {
  TestableScheduler scheduler = new TestableScheduler();
  String sourceObject = StringUtils.makeRandomString(5);
  ListenableFuture<String> lf = makeListenableFutureFactory().makeWithResult(sourceObject);
  String translatedObject = StringUtils.makeRandomString(10);
  ListenableFuture<String> mappedLF = lf.flatMap((s) -> {
    if (s == sourceObject) {
      return FutureUtils.immediateResultFuture(translatedObject);
    } else {
      // test failure
      return FutureUtils.immediateResultFuture(null);
    }
  }, scheduler);
  
  assertEquals(1, scheduler.tick());
  
  assertTrue(mappedLF.isDone());
  assertTrue(translatedObject == mappedLF.get());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void makeFailurePropagatingCompleteFutureWithResultNotCompleteTest() throws InterruptedException, TimeoutException, ExecutionException {
  String result = StringUtils.makeRandomString(5);
  List<SettableListenableFuture<?>> futures = new ArrayList<>(TEST_QTY);
  for (int i = 0; i < TEST_QTY; i++) {
    SettableListenableFuture<?> future = new SettableListenableFuture<>();
    if (i != 0) {
      future.setResult(null);
    }
    futures.add(future);
  }
  
  ListenableFuture<String> f = FutureUtils.makeFailurePropagatingCompleteFuture(futures, result);
  futures.get(0).setResult(null);
  
  verifyCompleteFuture(f, futures);
  assertEquals(result, f.get());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void mapAlreadyDoneTest() throws InterruptedException, ExecutionException {
  String sourceObject = StringUtils.makeRandomString(5);
  ListenableFuture<String> lf = makeListenableFutureFactory().makeWithResult(sourceObject);
  String translatedObject = StringUtils.makeRandomString(10);
  ListenableFuture<String> mappedLF = lf.map((s) -> {
    if (s == sourceObject) {
      return translatedObject;
    } else {
      // test failure
      return null;
    }
  });
  
  assertTrue(mappedLF.isDone());
  assertTrue(translatedObject == mappedLF.get());
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getBoolParseFail() {
  String key = StringUtils.makeRandomString(5);
  properties.put(key, StringUtils.makeRandomString(5));
  
  try {
    factory.getBoolValue(key);
    fail("Exception should have thrown");
  } catch (ParameterException e) {
    // expected
  }
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getIntTest() {
  String key = StringUtils.makeRandomString(5);
  int val = 10;
  properties.put(key, Integer.toString(val));
  
  assertEquals(val, factory.getIntValue(key));
}
 

import org.threadly.util.StringUtils; //导入方法依赖的package包/类
@Test
public void getIntParseFail() {
  String key = StringUtils.makeRandomString(5);
  properties.put(key, "s" + StringUtils.makeRandomString(5));
  
  try {
    factory.getIntValue(key);
    fail("Exception should have thrown");
  } catch (ParameterException e) {
    // expected
    assertTrue(e.getCause() instanceof NumberFormatException);
  }
}