import org.awaitility.Duration; //导入依赖的package包/类
protected void verifyResponse(InputStream pis, String response) {
    StringBuilder sb = new StringBuilder();
    try {
        await().atMost(Duration.TWO_SECONDS).until(() -> {
            while (true) {
                sb.append((char) pis.read());
                String s = sb.toString();
                if (s.contains(response)) {
                    break;
                }
            }
            return true;
        });
    } finally {
        System.out.println(sb.toString());
    }
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimple() throws IOException, TException, Failure {
    TestService.Iface client = new TestService.Client(new HttpClientHandler(
            this::endpoint));

    when(impl.test(any(net.morimekta.test.thrift.client.Request.class)))
            .thenReturn(new net.morimekta.test.thrift.client.Response("response"));

    Response response = client.test(new Request("request"));

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).until(() -> contentTypes.size() > 0);

    verify(impl).test(any(net.morimekta.test.thrift.client.Request.class));
    verifyNoMoreInteractions(impl);

    assertThat(response, is(equalToMessage(new Response("response"))));
    assertThat(contentTypes, is(equalTo(ImmutableList.of("application/vnd.apache.thrift.binary"))));
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimpleRequest() throws IOException, TException, Failure {
    TestService.Iface client = new TestService.Client(new HttpClientHandler(
            this::endpoint, factory(), provider, instrumentation));

    when(impl.test(any(net.morimekta.test.thrift.client.Request.class)))
            .thenReturn(new net.morimekta.test.thrift.client.Response("response"));

    Response response = client.test(new Request("request"));
    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).until(() -> contentTypes.size() > 0);

    verify(impl).test(any(net.morimekta.test.thrift.client.Request.class));
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), any(PServiceCall.class));
    verifyNoMoreInteractions(impl, instrumentation);

    assertThat(response, is(equalToMessage(new Response("response"))));
    assertThat(contentTypes, is(equalTo(ImmutableList.of("application/vnd.apache.thrift.binary"))));
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimpleRequest_oneway() throws IOException, TException, Failure {
    TestService.Iface client = new TestService.Client(new HttpClientHandler(
            this::endpoint, factory(), provider, instrumentation));

    AtomicBoolean called = new AtomicBoolean();
    doAnswer(i -> {
        called.set(true);
        return null;
    }).when(impl).onewayMethod();

    client.onewayMethod();

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);
    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).until(() -> contentTypes.size() > 0);

    verify(impl).onewayMethod();
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), isNull());
    verifyNoMoreInteractions(impl, instrumentation);

    assertThat(contentTypes, is(equalTo(ImmutableList.of("application/vnd.apache.thrift.binary"))));
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimpleRequest() throws IOException, Failure {
    AtomicBoolean called = new AtomicBoolean();
    when(impl.test(any(Request.class))).thenAnswer(i -> {
        called.set(true);
        return new Response("response");
    });

    TestService.Iface client = new TestService.Client(new HttpClientHandler(
            this::endpoint, factory(), provider));

    Response response = client.test(new Request("request"));

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    assertNotNull(response);
    assertEquals("{text:\"response\"}", response.asString());
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), any(PServiceCall.class));
    verifyNoMoreInteractions(instrumentation);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimpleRequest_exception() throws IOException, Failure {
    AtomicBoolean called = new AtomicBoolean();
    when(impl.test(any(Request.class))).thenAnswer(i -> {
        called.set(true);
        throw Failure.builder()
               .setText("failure")
               .build();
    });

    TestService.Iface client = new TestService.Client(new HttpClientHandler(this::endpoint,
                                                                            factory(),
                                                                            provider));

    try {
        client.test(new Request("request"));
        fail("No exception");
    } catch (Failure ex) {
        assertEquals("failure", ex.getText());
    }

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), any(PServiceCall.class));
    verifyNoMoreInteractions(instrumentation);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testThriftClient_void() throws TException, IOException, Failure {
    ApacheHttpTransport transport = new ApacheHttpTransport();
    THttpClient httpClient = new THttpClient(endpoint().toString(), transport.getHttpClient());
    TBinaryProtocol protocol = new TBinaryProtocol(httpClient);
    net.morimekta.test.thrift.service.TestService.Iface client =
            new net.morimekta.test.thrift.service.TestService.Client(protocol);

    AtomicBoolean called = new AtomicBoolean();
    doAnswer(i -> {
        called.set(true);
        return null;
    }).when(impl).voidMethod(55);

    client.voidMethod(55);

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(impl).voidMethod(55);
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), any(PServiceCall.class));
    verifyNoMoreInteractions(impl, instrumentation);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testThriftClient_oneway() throws TException, IOException, Failure {
    ApacheHttpTransport transport = new ApacheHttpTransport();
    THttpClient httpClient = new THttpClient(endpoint().toString(), transport.getHttpClient());
    TBinaryProtocol protocol = new TBinaryProtocol(httpClient);
    net.morimekta.test.thrift.service.TestService.Iface client =
            new net.morimekta.test.thrift.service.TestService.Client(protocol);

    AtomicBoolean called = new AtomicBoolean();
    doAnswer(i -> {
        called.set(true);
        return null;
    }).when(impl).ping();

    client.ping();

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(impl).ping();
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), isNull());
    verifyNoMoreInteractions(impl, instrumentation);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testThriftClient_failure() throws TException, IOException, Failure {
    ApacheHttpTransport transport = new ApacheHttpTransport();
    THttpClient httpClient = new THttpClient(endpoint().toString(), transport.getHttpClient());
    TBinaryProtocol protocol = new TBinaryProtocol(httpClient);
    net.morimekta.test.thrift.service.TestService.Iface client =
            new net.morimekta.test.thrift.service.TestService.Client(protocol);

    AtomicBoolean called = new AtomicBoolean();
    doAnswer(i -> {
        called.set(true);
        throw new Failure("test");
    }).when(impl).voidMethod(55);

    try {
        client.voidMethod(55);
    } catch (net.morimekta.test.thrift.service.Failure e) {
        assertEquals("test", e.getText());
    }

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(impl).voidMethod(55);
    verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), any(PServiceCall.class));
    verifyNoMoreInteractions(impl, instrumentation);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testSimpleRequest() throws IOException, TException, Failure {
    AtomicBoolean called = new AtomicBoolean();
    when(impl.test(new net.morimekta.test.thrift.thrift.service.Request("test")))
            .thenAnswer(i -> {
                called.set(true);
                return new net.morimekta.test.thrift.thrift.service.Response("response");
            });

    MyService.Iface client = new MyService.Client(new SocketClientHandler(serializer, address));

    Response response = client.test(new Request("test"));

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);
    verify(impl).test(any(net.morimekta.test.thrift.thrift.service.Request.class));

    assertThat(response, is(equalToMessage(new Response("response"))));
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testOnewayRequest() throws IOException, TException, Failure {
    MyService.Iface client = new MyService.Client(new SocketClientHandler(serializer, address));

    AtomicBoolean called = new AtomicBoolean();
    doAnswer(i -> {
        called.set(true);
        return null;
    }).when(impl).ping();

    client.ping();

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(impl).ping();
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testOnewayRequest()
        throws IOException, TException, net.morimekta.test.providence.thrift.service.Failure, InterruptedException {
    MyService.Iface client = new MyService.Client(new NonblockingSocketClientHandler(serializer, address));

    AtomicBoolean called = new AtomicBoolean(false);
    doAnswer(i -> {
        called.set(true);
        return null;
    }).when(impl).ping();

    client.ping();

    waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

    verify(impl).ping();
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testOneway() throws IOException, TException, Failure, InterruptedException {
    try (TSocket socket = new TSocket("localhost", port)) {
        socket.open();
        TProtocol protocol = new TBinaryProtocol(socket);
        Client client = new Client(protocol);

        AtomicBoolean called = new AtomicBoolean();
        doAnswer(i -> {
            called.set(true);
            return null;
        }).when(impl).ping();

        client.ping();

        waitAtMost(Duration.ONE_HUNDRED_MILLISECONDS).untilTrue(called);

        verify(impl).ping();
        verify(instrumentation).onComplete(anyDouble(), any(PServiceCall.class), isNull());
        verifyNoMoreInteractions(impl, instrumentation);
    }
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void testExpiry() throws Exception {
  pipelineStoreTask.create("user", "aaaa", "label","blah", false, false);
  Runner runner = pipelineManager.getRunner("aaaa", "0");
  pipelineStateStore.saveState("user", "aaaa", "0", PipelineStatus.RUNNING_ERROR, "blah", null, ExecutionMode.STANDALONE, null, 0, 0);
  assertEquals(PipelineStatus.RUNNING_ERROR, runner.getState().getStatus());
  pipelineStateStore.saveState("user", "aaaa", "0", PipelineStatus.RUN_ERROR, "blah", null, ExecutionMode.STANDALONE, null, 0, 0);

  pipelineManager.stop();
  pipelineStoreTask.stop();

  pipelineStateStore.saveState("user", "aaaa", "0", PipelineStatus.RUNNING_ERROR, "blah", null, ExecutionMode
      .STANDALONE, null, 0, 0);
  pipelineManager = null;
  setUpManager(100, 0, false);
  await().atMost(Duration.FIVE_SECONDS).until(new Callable<Boolean>() {
    @Override
    public Boolean call() throws Exception {
      return !((StandaloneAndClusterPipelineManager) pipelineManager).isRunnerPresent("aaaa", "0");
    }
  });
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void loginAndLogout() throws Exception {
    final int baselineReplicationLogCount = replicationLogCount();

    // Log in from the 1st replica.
    final AggregatedHttpMessage loginRes = login(replica1, USERNAME, PASSWORD);
    assertThat(loginRes.status()).isEqualTo(HttpStatus.OK);

    // Ensure that only one replication log is produced.
    assertThat(replicationLogCount()).isEqualTo(baselineReplicationLogCount + 1);

    // Ensure authorization works at the 2nd replica.
    final String sessionId = loginRes.content().toStringAscii();
    await().pollDelay(Duration.TWO_HUNDRED_MILLISECONDS)
           .pollInterval(Duration.ONE_SECOND)
           .untilAsserted(() -> assertThat(usersMe(replica2, sessionId).status()).isEqualTo(HttpStatus.OK));

    // Ensure that no replication log is produced.
    assertThat(replicationLogCount()).isEqualTo(baselineReplicationLogCount + 1);

    // Log out from the 1st replica.
    assertThat(logout(replica1, sessionId).status()).isEqualTo(HttpStatus.OK);

    // Ensure that only one replication log is produced.
    assertThat(replicationLogCount()).isEqualTo(baselineReplicationLogCount + 2);

    // Ensure authorization fails at the 2nd replica.
    await().pollDelay(Duration.TWO_HUNDRED_MILLISECONDS)
           .pollInterval(Duration.ONE_SECOND)
           .untilAsserted(() -> assertThat(usersMe(replica2, sessionId).status())
                   .isEqualTo(HttpStatus.UNAUTHORIZED));
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void doWorkInThread() throws Exception {
    World world = new World();
    Blockchain blockchain = world.getBlockChain();

    Assert.assertEquals(0, blockchain.getBestBlock().getNumber());

    MinerServerImpl minerServer = getMinerServer(blockchain);
    MinerClientImpl minerClient = getMinerClient(minerServer);

    minerServer.buildBlockToMine(blockchain.getBestBlock(), false);
    Thread thread = minerClient.createDoWorkThread();
    thread.start();
    try {

        Awaitility.await().timeout(Duration.FIVE_SECONDS).until(new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                return minerClient.isMining();
            }
        });

        Assert.assertTrue(minerClient.isMining());
    } finally {
        thread.interrupt(); // enought ?
        minerClient.stop();
    }
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void contextTransfersOneHopAsync() throws Exception {
    Metadata.Key<String> ctxKey = Metadata.Key.of("ctx-context-key", Metadata.ASCII_STRING_MARSHALLER);
    String expectedCtxValue = "context-value";
    AtomicReference<String> ctxValue = new AtomicReference<>();

    // Service
    GreeterGrpc.GreeterImplBase svc = new GreeterGrpc.GreeterImplBase() {
        @Override
        public void sayHello(HelloRequest request, StreamObserver<HelloResponse> responseObserver) {
            ctxValue.set(AmbientContext.current().get(ctxKey));
            responseObserver.onNext(HelloResponse.newBuilder().setMessage("Hello " + request.getName()).build());
            responseObserver.onCompleted();
        }
    };

    // Plumbing
    serverRule1.getServiceRegistry().addService(ServerInterceptors
            .intercept(svc, new AmbientContextServerInterceptor("ctx-")));
    GreeterGrpc.GreeterFutureStub stub = GreeterGrpc
            .newFutureStub(serverRule1.getChannel())
            .withInterceptors(new AmbientContextClientInterceptor("ctx-"));

    // Test
    AmbientContext.initialize(Context.current()).run(() -> {
        AmbientContext.current().put(ctxKey, expectedCtxValue);
        ListenableFuture<HelloResponse> futureResponse = stub.sayHello(HelloRequest.newBuilder().setName("world").build());

        // Verify response callbacks still have context
        MoreFutures.onSuccess(
                futureResponse,
                response -> assertThat(AmbientContext.current().get(ctxKey)).isEqualTo(expectedCtxValue),
                Context.currentContextExecutor(Executors.newSingleThreadExecutor()));

        await().atMost(Duration.ONE_SECOND).until(futureResponse::isDone);
    });

    assertThat(ctxValue.get()).isEqualTo(expectedCtxValue);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Override
protected void after() {
    server.stop();
    // server.stop is not instantaneous
    Awaitility.await().atMost(Duration.FIVE_SECONDS).until(() -> {
        try {
            getTarget("/").request().get();
        } catch (ProcessingException e) {
            return true;
        }
        return false;
    });
    client.close();
    CookieHandler.setDefault(null);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
@Test
public void test_metric_field_does_not_exist_is_not_stored() {
  json ()
    .remove ("@metric") // Remove field that is used to create metric
    .<JsonEvent>toObservable ()
    .flatMap (graphite ("@timestamp", "ISO_8601"))
    .toBlocking ().subscribe ();

  await ().timeout (Duration.ONE_SECOND).until (() -> receivedMetrics.size () == 0);
}
 

import org.awaitility.Duration; //导入依赖的package包/类
void waitUntilReady()
{
    System.out.println( ">> Riak HealthCheck BEGIN" );
    Instant start = Instant.now();
    Awaitility.await()
              .pollDelay( Duration.ZERO )
              .pollInterval( Duration.ONE_SECOND )
              .timeout( Duration.ONE_MINUTE )
              .until( new HealthCheck() );
    System.out.println( ">> Riak HealthCheck END, took " + java.time.Duration.between( start, Instant.now() ) );
}