Java Theory类代码示例

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void close_actor_and_watchdog_detects(final AgentClusterRule agentCluster)
        throws ValidationException, IOException, InterruptedException {
    before(agentCluster);
    File rdvFileInit = folder.newFile();
    ActorConfig actorConfig = configWithInitRdv(TestActorWriter.class.getName(), rdvFileInit);
    ManagedActor actor = actorManager.createActor(actorConfig);

    ProcessWatchDogThread watchDogThread = actorManager.getProcesses().get(DUMMY_ACTOR);
    assertNotNull(watchDogThread);

    // Sync with process
    verifyFileContentWithin(rdvFileInit, TestActorWriter.OK, MAX_TIMEOUT_SEC, TimeUnit.SECONDS);

    actor.close();

    // We do not check the fact that the shutdown hook is actually called here
    joinUninterruptibly(watchDogThread);

    assertThat(actorManager.getProcesses().size(), is(0));
    assertThat(watchDogThread.hasProcessExited(), is(true));
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void close_actor_twice(final AgentClusterRule agentCluster)
        throws ValidationException, IOException, InterruptedException {
    before(agentCluster);
    File rdvFileInit = folder.newFile();
    ActorConfig actorConfig = configWithInitRdv(TestActorWriter.class.getName(), rdvFileInit);
    ManagedActor actor = actorManager.createActor(actorConfig);

    ProcessWatchDogThread watchDogThread = actorManager.getProcesses().get(DUMMY_ACTOR);

    verifyFileContentWithin(rdvFileInit, TestActorWriter.OK, MAX_TIMEOUT_SEC, TimeUnit.SECONDS);

    actor.close();
    actor.close();

    // We do not check the fact that the shutdown hook is actually called here
    joinUninterruptibly(watchDogThread);

    assertThat(actorManager.getProcesses().size(), is(0));
    assertThat(watchDogThread.hasProcessExited(), is(true));
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
/**
 * Here we monitor the {@link SystemWatcherActor} process using the {@link ProcessWatcherActor}
 *
 * @throws ExecutionException Not expected
 */
@Theory
public void stopWatch_process_monitoring(boolean forked, final Supplier supplier) throws ExecutionException {
    BenchRule benchRule = (BenchRule) supplier.get();
    before(benchRule);
    MetricsRepository metricsRepository = benchRule.metricsRepository();
    Future<MetricValuesMessage> metrics = metricsRepository.expectValuesFor(PROCESS_WATCHER);

    Actors.ActorHandle systemWatcher = createAndInitSystemWatcher(forked);
    Actors.ActorHandle processesWatcher = createProcessWatcher(forked);
    ActorDeployInfo deployInfo = getUninterruptibly(processesWatcher.actorInitialization());

    processesWatcher.send(PROCESS_WATCHER.getName(), startStopwatch(deployInfo.getPid(), METRIC_KEY));

    sleepUninterruptibly(2, TimeUnit.SECONDS);

    processesWatcher.send(PROCESS_WATCHER.getName(), stopStopwatch(deployInfo.getPid(), METRIC_KEY));

    processesWatcher.dumpMetrics();
    sleepUninterruptibly(1, TimeUnit.SECONDS);
    assertThat(getUninterruptibly(metrics).metrics().size(), is(13));
    getUninterruptibly(systemWatcher.close());
    getUninterruptibly(processesWatcher.close());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void sampling_process_monitoring(boolean forked, final Supplier supplier) throws ExecutionException {
    BenchRule benchRule = (BenchRule) supplier.get();
    before(benchRule);
    Future<MetricValuesMessage> metrics = metricsRepository.expectValuesFor(PROCESS_WATCHER);

    Actors.ActorHandle systemWatcher = createAndInitSystemWatcher(forked);
    Actors.ActorHandle processesWatcher = createProcessWatcher(forked);
    ActorDeployInfo deployInfo = getUninterruptibly(processesWatcher.actorInitialization());

    processesWatcher.send(PROCESS_WATCHER.getName(), startSampling(deployInfo.getPid(), 1, METRIC_KEY));

    sleepUninterruptibly(2, TimeUnit.SECONDS);

    processesWatcher.send(PROCESS_WATCHER.getName(), stopSampling(deployInfo.getPid()));

    processesWatcher.dumpMetrics();
    sleepUninterruptibly(1, TimeUnit.SECONDS);
    assertTrue(getUninterruptibly(metrics).metrics().size() > 0);
    getUninterruptibly(systemWatcher.close());
    getUninterruptibly(processesWatcher.close());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void create_and_close_forked_actor_on_agent(final Supplier supplier) throws Exception {
    BenchRule benchRule = (BenchRule) supplier.get();
    before(benchRule);

    List<String> jvmArgs = new ArrayList<>();
    jvmArgs.add("-Xmx128m");
    ActorSync sync = createForkedActor(jvmArgs);

    // Verify that the forked actor is properly registered
    assertThat(actorRegistry.all().size(), is(1));
    assertThat(actorRegistry.byKey(DUMMY_ACTOR).getDeployInfo().getCommand(), hasItem(jvmArgs.get(0)));
    assertTrue(actorRegistry.byKey(DUMMY_ACTOR).getDeployInfo().getPid() > 0);
    assertNotNull(actorRegistry.byKey(DUMMY_ACTOR).getDeployInfo().getEndpoint());

    resourceManager.closeActor(DUMMY_ACTOR);

    sync.assertActorClosed();
    assertThat(actorRegistry.all().size(), is(0));
    after(benchRule);
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void repeatWhenConsumerSaysSo(Duration[] intervals, Integer deliveryCount) {
    assumeThat(deliveryCount, lessThanOrEqualTo(intervals.length));
    
    Integer sentData = 2;
    MessageRepeater<Integer> target = newRepeater(intervals, Repeat);
    Optional<Schedule<Integer>> schedule = 
            target.consume(newCountedSchedule(deliveryCount), sentData);
    
    assertTrue(schedule.isPresent());
    assertNear(intervals[deliveryCount - 1], schedule.get().when());
    assertThat(schedule.get().what(), is(sentData));
    
    assertTrue(consumedData.isPresent());
    assertThat(consumedData.get(), is(sentData));
    
    assertFalse(exceededRedeliveryData.isPresent());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void hanlderNeverCalledOnLastDeliveryIfConsumerStops(
        Duration[] intervals, Integer deliveryCount) {
    assumeThat(deliveryCount, greaterThan(intervals.length));
    
    Integer sentData = 3;
    MessageRepeater<Integer> target = newRepeater(intervals, Stop);
    Optional<Schedule<Integer>> schedule = 
            target.consume(newCountedSchedule(deliveryCount), sentData);
    
    assertFalse(schedule.isPresent());
    
    assertTrue(consumedData.isPresent());
    assertThat(consumedData.get(), is(sentData));
    assertFalse(exceededRedeliveryData.isPresent());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void shouldApplyRightViewToLeftViewWhenShouldCreate(@FromDataPoints("ne left") View<TestNode> left,
                                                           @FromDataPoints("ne left") View<TestNode> right) {
    // given
    if (!(left instanceof NodeView)
            && (!(left instanceof NodeSetView) || !(((NodeSetView) left).iterator().next() instanceof NodeView))) {
        expectedException.expect(XmlBuilderException.class);
    }
    when(leftExpr.resolve(any(ViewContext.class))).thenReturn(left);
    when(rightExpr.resolve(any(ViewContext.class))).thenReturn(right);
    ViewContext<TestNode> context = new ViewContext<>(navigator, parentNode, true);

    // when
    View<TestNode> result = new NotEqualsExpr(leftExpr, rightExpr).resolve(context);

    // then
    assertThat(result).isEqualTo(BooleanView.of(true));
    verify(navigator).setText(any(TestNode.class), eq(Boolean.toString(!right.toBoolean())));
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void equalityAgreesWithHashing(
        FutureTimepoint when1, String what1,
        FutureTimepoint when2, String what2) {
    Schedule<String> s1 = new Schedule<>(when1, what1);
    Schedule<String> s2 = new Schedule<>(when2, what2);

    if (when1.equals(when2) && what1.equals(what2)) {
        assertTrue(s1.equals(s2));
        assertTrue(s2.equals(s1));
        assertThat(s1.hashCode(), is(s2.hashCode()));
    } else {
        assertFalse(s1.equals(s2));
        assertFalse(s2.equals(s1));
        assertThat(s1.hashCode(), is(not(s2.hashCode())));
    }
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void fromStringYieldsSameClassPathAsThatBuiltByAppendingPaths(
        Path p1, Path p2, Path p3) {
    String cp = p1 + Separator + p2 + Separator + p3;
    ClassPath parsed = ClassPathFactory.fromString(cp);
    ClassPath built = new ClassPath().add(p1, p2, p3);
    
    assertNotNull(parsed);
    assertThat(parsed, is(built));
    
    String parsedToString = parsed.toString();
    String builtToString = built.toString();
    assertNotNull(parsedToString);
    assertNotNull(builtToString);        
    assertThat(parsedToString, is(builtToString));
    
    Stream<Path> parsedToStream = parsed.toStream();
    Stream<Path> builtToStream = built.toStream();
    assertNotNull(parsedToStream);
    assertNotNull(builtToStream);
    assertArrayEquals(parsedToStream.toArray(), builtToStream.toArray());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void addOrderIsRespected(Path p1, Path p2, Path p3) {
    String[] actual = new ClassPath()
                     .add(p1, p2, p3)
                     .toStream()
                     .map(Path::toString)
                     .toArray(String[]::new);
    
    LinkedHashSet<String> ps = new LinkedHashSet<>();  // respects add order
    ps.add(p1.toString());
    ps.add(p2.toString());
    ps.add(p3.toString());
    ps.remove("");
    String[] expected = ps.toArray(new String[0]);
    
    assertArrayEquals(expected, actual);
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void null_parameters_invalid(final AgentClusterRule agentCluster) {
    before(agentCluster);
    NullPointerTester tester = new NullPointerTester();

    tester.testAllPublicConstructors(ForkedActorManager.class);
    tester.testAllPublicInstanceMethods(actorManager);
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void create_actor_init_called(final AgentClusterRule agentCluster)
        throws ValidationException, IOException, InterruptedException {
    before(agentCluster);
    File rdvFile = folder.newFile();
    ActorConfig actorConfig = configWithInitRdv(TestActorWriter.class.getName(), rdvFile);

    ManagedActor actor = actorManager.createActor(actorConfig);

    assertNotNull(actor);
    assertThat(actor.getKey(), is(DUMMY_ACTOR));
    verifyFileContentWithin(rdvFile, TestActorWriter.OK, MAX_TIMEOUT_SEC, TimeUnit.SECONDS);
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
/**
 * 正常系.
 * @param f テストデータ
 * @throws Exception Exception
 */
@Theory
public void 正常系206(Fixture f) throws Exception {
    // 単一バイトレンジ指定のテストなので0固定
    int byteRangeSpecIndex = 0;

    // Rangeヘッダパース
    RangeHeaderHandler range = RangeHeaderHandler.parse(f.rangeHeaderField, f.contentSize);

    // byte-range-setの数チェック
    assertEquals(1, range.getByteRangeSpecCount());

    List<ByteRangeSpec> brss = range.getByteRangeSpecList();
    ByteRangeSpec brs = brss.get(byteRangeSpecIndex);

    // 開始・終了値チェック
    assertEquals(f.expectedFirstBytePos, brs.getFirstBytePos());
    assertEquals(f.expectedLastBytePos, brs.getLastBytePos());

    // Rangeヘッダが有効であることのチェック
    assertEquals(true, range.isValid());

    // 範囲外の指定でないことをチェック
    assertEquals(true, range.isSatisfiable());

    // Content-Lengthのチェック
    assertEquals(f.expectedContentSize, brs.getContentLength());

    // Content-Rangeヘッダのチェック
    assertEquals(f.expectedContentRange, brs.makeContentRangeHeaderField());
}
 

import org.junit.experimental.theories.Theory; //导入依赖的package包/类
@Theory
public void writeThenReadIsIdentity(byte[] input) throws Exception {
    ByteArrayInputStream source = encrypt(input);
    byte[] decrypted = decryptionFilter.read(source);

    assertArrayEquals(input, decrypted);
}