Пример #1
0
 @Test
 public void runTestWithFailAfterAsync() throws Exception {
   RuntimeException failure = new RuntimeException();
   BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 queue.add(context.async());
                 throw failure;
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   Async async = queue.poll(2, TimeUnit.SECONDS);
   async.complete();
   assertTrue(reporter.completed());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertFalse(result.succeeded());
   assertTrue(result.failed());
   assertNotNull(result.failure());
   assertSame(failure, result.failure().cause());
 }
Пример #2
0
 @Test
 public void testAssertAsyncFailureHandlerThrowsFailure() throws Exception {
   RuntimeException cause = new RuntimeException();
   BlockingQueue<Handler<AsyncResult<String>>> handlerQueue = new ArrayBlockingQueue<>(1);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 handlerQueue.add(
                     context.<String>asyncAssertFailure(
                         r -> {
                           throw cause;
                         }));
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   Handler<AsyncResult<String>> handler = handlerQueue.poll(2, TimeUnit.SECONDS);
   handler.handle(Future.failedFuture(new Throwable()));
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   assertTrue(reporter.results.get(0).failed());
   assertSame(cause, reporter.results.get(0).failure().cause());
 }
Пример #3
0
 @Test
 public void runTestWithAsyncCompletion() throws Exception {
   BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1);
   AtomicInteger count = new AtomicInteger();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 count.compareAndSet(0, 1);
                 queue.add(context.async());
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   Async async = queue.poll(2, TimeUnit.SECONDS);
   assertEquals(1, count.get());
   assertFalse(reporter.completed());
   completeAsync.accept(async);
   reporter.await();
   assertTrue(reporter.completed());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertTrue(result.succeeded());
   assertFalse(result.failed());
   assertNull(result.failure());
 }
Пример #4
0
 @Test
 public void testAssertAsyncFailureHandlerSucceededAsync() throws Exception {
   BlockingQueue<Handler<AsyncResult<String>>> handlerQueue = new ArrayBlockingQueue<>(1);
   BlockingQueue<Async> resultQueue = new ArrayBlockingQueue<>(1);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 handlerQueue.add(
                     context.<String>asyncAssertFailure(
                         r -> {
                           resultQueue.add(context.async());
                         }));
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   Handler<AsyncResult<String>> handler = handlerQueue.poll(2, TimeUnit.SECONDS);
   handler.handle(Future.failedFuture(new Throwable()));
   Async result = resultQueue.poll(2, TimeUnit.SECONDS);
   assertFalse(reporter.completed());
   result.complete();
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   assertEquals("my_test", reporter.results.get(0).name());
   assertFalse(reporter.results.get(0).failed());
 }
Пример #5
0
 @Test
 public void runTest() {
   AtomicInteger count = new AtomicInteger();
   AtomicBoolean sameContext = new AtomicBoolean();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 sameContext.set(checkTest(context));
                 count.compareAndSet(0, 1);
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertTrue(sameContext.get());
   assertEquals(1, count.get());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertTrue(result.succeeded());
   assertFalse(result.failed());
   assertNull(result.failure());
 }
Пример #6
0
 @Test
 public void reportFailureAfterTestCompleted() {
   AtomicReference<TestContext> testRef = new AtomicReference<>();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test("my_test_1", testRef::set)
           .test(
               "my_test_2",
               context -> {
                 try {
                   testRef.get().fail();
                 } catch (AssertionError e) {
                 }
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(1, reporter.exceptions.size());
   assertEquals(2, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test_1", result.name());
   assertTrue(result.succeeded());
   assertNull(result.failure());
   result = reporter.results.get(1);
   assertEquals("my_test_2", result.name());
   assertTrue(result.succeeded());
   assertNull(result.failure());
 }
Пример #7
0
 @Test
 public void testAssertAsyncFailureFailed() throws Exception {
   BlockingQueue<Handler<AsyncResult<String>>> handlerQueue = new ArrayBlockingQueue<>(1);
   AtomicBoolean called = new AtomicBoolean();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 handlerQueue.add(
                     context.<String>asyncAssertFailure(
                         r -> {
                           called.set(true);
                         }));
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   Handler<AsyncResult<String>> handler = handlerQueue.poll(2, TimeUnit.SECONDS);
   handler.handle(Future.succeededFuture("foo"));
   reporter.await();
   assertFalse(called.get());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   assertEquals("my_test", reporter.results.get(0).name());
   assertTrue(reporter.results.get(0).failed());
 }
Пример #8
0
 private void failTest(Handler<TestContext> thrower) {
   AtomicReference<Throwable> failure = new AtomicReference<>();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 try {
                   thrower.handle(context);
                 } catch (Error | RuntimeException e) {
                   failure.set(e);
                   throw e;
                 }
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertFalse(result.succeeded());
   assertTrue(result.failed());
   assertNotNull(result.failure());
   assertSame(failure.get().getMessage(), result.failure().message());
   assertSame(failure.get(), result.failure().cause());
 }
  @Test
  public void testConnectCancellation() throws Throwable {
    // Check if the test can be executed or should be skipped because of no network/internet
    // connection
    // See https://github.com/netty/netty/issues/1474
    boolean badHostTimedOut = true;
    Socket socket = new Socket();
    try {
      socket.connect(new InetSocketAddress(BAD_HOST, BAD_PORT), 10);
    } catch (ConnectException e) {
      badHostTimedOut = false;
      // is thrown for no route to host when using Socket connect
    } catch (Exception e) {
      // ignore
    } finally {
      try {
        socket.close();
      } catch (IOException e) {
        // ignore
      }
    }

    assumeThat(
        "The connection attempt to " + BAD_HOST + " does not time out.", badHostTimedOut, is(true));

    run();
  }
Пример #10
0
 @Test
 public void runTestWithAsyncCompletionAfterFailureInTest() throws Exception {
   AtomicBoolean completed = new AtomicBoolean();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 Async async = context.async();
                 try {
                   context.fail("msg");
                 } catch (AssertionError ignore) {
                 }
                 async.complete();
                 completed.set(true);
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertTrue(completed.get());
   assertTrue(reporter.completed());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertTrue(result.failed());
 }
Пример #11
0
 @Test
 public void runTestWithAsyncCompletionCompletedInTest() throws Exception {
   AtomicBoolean ok = new AtomicBoolean();
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 Async async = context.async();
                 async.complete();
                 try {
                   async.complete();
                 } catch (IllegalStateException ignore) {
                 }
                 ok.set(true);
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertTrue(ok.get());
   assertTrue(reporter.completed());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertTrue(result.succeeded());
   assertFalse(result.failed());
   assertNull(result.failure());
 }
Пример #12
0
 @Test
 public void runTestWithFailBeforeAsync() throws Exception {
   AtomicReference<AssertionError> failure = new AtomicReference<>();
   BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 try {
                   context.fail();
                 } catch (AssertionError e) {
                   failure.set(e);
                 }
                 queue.add(context.async());
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   Async async = queue.poll(2, TimeUnit.SECONDS);
   async.complete();
   assertTrue(reporter.completed());
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   TestResult result = reporter.results.get(0);
   assertEquals("my_test", result.name());
   assertFalse(result.succeeded());
   assertTrue(result.failed());
   assertNotNull(result.failure());
   assertSame(failure.get(), result.failure().cause());
 }
Пример #13
0
 @Test
 public void timeExecution() {
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 Async async = context.async();
                 new Thread() {
                   @Override
                   public void run() {
                     try {
                       Thread.sleep(15);
                     } catch (InterruptedException ignore) {
                     } finally {
                       async.complete();
                     }
                   }
                 }.start();
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   assertEquals("my_test", reporter.results.get(0).name());
   assertFalse(reporter.results.get(0).failed());
   assertTrue(reporter.results.get(0).durationTime() >= 15);
 }
Пример #14
0
 @Test
 public void afterIsRunAfterFailure() throws Exception {
   for (int i = 0; i < 2; i++) {
     AtomicInteger count = new AtomicInteger();
     TestSuite suite =
         TestSuite.create("my_suite")
             .test(
                 "my_test",
                 context -> {
                   count.compareAndSet(0, 1);
                   context.fail("the_message");
                 });
     if (i == 0) {
       suite = suite.after(context -> count.compareAndSet(1, 2));
     } else {
       suite = suite.afterEach(context -> count.compareAndSet(1, 2));
     }
     TestReporter reporter = new TestReporter();
     run(suite, reporter);
     reporter.await();
     assertEquals(2, count.get());
     assertEquals(0, reporter.exceptions.size());
     assertEquals(1, reporter.results.size());
     assertEquals("my_test", reporter.results.get(0).name());
     assertTrue(reporter.results.get(0).failed());
     assertEquals("the_message", reporter.results.get(0).failure().message());
   }
 }
Пример #15
0
 @Test
 public void failAfter() throws Exception {
   for (int i = 0; i < 2; i++) {
     AtomicInteger count = new AtomicInteger();
     int val = i;
     TestSuite suite =
         TestSuite.create("my_suite")
             .test("my_test_1", context -> count.compareAndSet(0, 1))
             .test(
                 "my_test_2",
                 context -> {
                   if (val == 0) {
                     count.compareAndSet(1, 2);
                   } else {
                     count.compareAndSet(2, 3);
                   }
                 });
     if (i == 0) {
       suite =
           suite.after(
               context -> {
                 count.incrementAndGet();
                 context.fail("the_message");
               });
     } else {
       AtomicBoolean failed = new AtomicBoolean();
       suite =
           suite.afterEach(
               context -> {
                 count.incrementAndGet();
                 if (failed.compareAndSet(false, true)) {
                   context.fail("the_message");
                 }
               });
     }
     TestReporter reporter = new TestReporter();
     run(suite, reporter);
     reporter.await();
     if (i == 0) {
       assertEquals(3, count.get());
       assertEquals(1, reporter.exceptions.size());
       assertEquals(2, reporter.results.size());
       assertEquals("my_test_1", reporter.results.get(0).name());
       assertTrue(reporter.results.get(0).succeeded());
       assertEquals("my_test_2", reporter.results.get(1).name());
       assertTrue(reporter.results.get(1).succeeded());
     } else {
       assertEquals(4, count.get());
       assertEquals(0, reporter.exceptions.size());
       assertEquals(2, reporter.results.size());
       assertEquals("my_test_1", reporter.results.get(0).name());
       assertTrue(reporter.results.get(0).failed());
       assertEquals("my_test_2", reporter.results.get(1).name());
       assertTrue(reporter.results.get(1).succeeded());
     }
   }
 }
Пример #16
0
 @Test
 public void runAfter() throws Exception {
   for (int i = 0; i < 2; i++) {
     AtomicInteger count = new AtomicInteger();
     AtomicBoolean sameContext = new AtomicBoolean();
     int val = i;
     TestSuite suite =
         TestSuite.create("my_suite")
             .test(
                 "my_test_1",
                 context -> {
                   count.compareAndSet(0, 1);
                 })
             .test(
                 "my_test_2",
                 context -> {
                   if (val == 0) {
                     count.compareAndSet(1, 2);
                   } else {
                     count.compareAndSet(2, 3);
                   }
                 });
     if (i == 0) {
       suite =
           suite.after(
               context -> {
                 sameContext.set(checkTest(context));
                 count.incrementAndGet();
               });
     } else {
       suite =
           suite.afterEach(
               context -> {
                 sameContext.set(checkTest(context));
                 count.incrementAndGet();
               });
     }
     TestReporter reporter = new TestReporter();
     run(suite, reporter);
     reporter.await();
     assertEquals(i == 0 ? 3 : 4, count.get());
     assertTrue(sameContext.get());
     assertEquals(0, reporter.exceptions.size());
     assertEquals(2, reporter.results.size());
     assertEquals("my_test_1", reporter.results.get(0).name());
     assertTrue(reporter.results.get(0).succeeded());
     assertEquals("my_test_2", reporter.results.get(1).name());
     assertTrue(reporter.results.get(1).succeeded());
   }
 }
Пример #17
0
 @Test
 public void runBeforeWithAsyncCompletion() throws Exception {
   for (int i = 0; i < 2; i++) {
     AtomicInteger count = new AtomicInteger();
     AtomicBoolean sameContext = new AtomicBoolean();
     BlockingQueue<Async> queue = new ArrayBlockingQueue<>(1);
     TestSuite suite =
         TestSuite.create("my_suite")
             .test(
                 "my_test",
                 context -> {
                   count.compareAndSet(1, 2);
                   sameContext.set(checkTest(context));
                 });
     if (i == 0) {
       suite =
           suite.before(
               context -> {
                 count.compareAndSet(0, 1);
                 queue.add(context.async());
               });
     } else {
       suite =
           suite.beforeEach(
               context -> {
                 count.compareAndSet(0, 1);
                 queue.add(context.async());
               });
     }
     TestReporter reporter = new TestReporter();
     run(suite, reporter);
     Async async = queue.poll(2, TimeUnit.SECONDS);
     completeAsync.accept(async);
     reporter.await();
     assertEquals(2, count.get());
     assertTrue(sameContext.get());
     assertEquals(0, reporter.exceptions.size());
     assertEquals(1, reporter.results.size());
     assertEquals("my_test", reporter.results.get(0).name());
     assertTrue(reporter.results.get(0).succeeded());
   }
 }
Пример #18
0
 @Test
 public void testTimeout() throws Exception {
   BlockingQueue<Async> queue = new ArrayBlockingQueue<>(2);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test("my_test0", context -> queue.add(context.async()))
           .test("my_test1", context -> queue.add(context.async()));
   TestReporter reporter = new TestReporter();
   run(suite, reporter, 300); // 300 ms
   reporter.await(); // Wait until timeout and suite completes
   assertEquals(2, reporter.results.size());
   for (int i = 0; i < 2; i++) {
     Async async = queue.poll(2, TimeUnit.SECONDS);
     assertEquals("my_test" + i, reporter.results.get(i).name());
     assertTrue(reporter.results.get(i).failed());
     assertNotNull(reporter.results.get(i).failure());
     assertTrue(reporter.results.get(i).failure().cause() instanceof TimeoutException);
     async.complete();
   }
 }
Пример #19
0
 @Test
 public void failBefore() throws Exception {
   for (int i = 0; i < 2; i++) {
     AtomicInteger count = new AtomicInteger();
     TestSuite suite =
         TestSuite.create("my_suite")
             .test("my_test_1", context -> count.incrementAndGet())
             .test("my_test_2", context -> count.incrementAndGet());
     if (i == 0) {
       suite.before(
           context -> {
             throw new RuntimeException();
           });
     } else {
       AtomicBoolean failed = new AtomicBoolean();
       suite.beforeEach(
           context -> {
             if (failed.compareAndSet(false, true)) {
               throw new RuntimeException();
             }
           });
     }
     TestReporter reporter = new TestReporter();
     run(suite, reporter);
     reporter.await();
     if (i == 0) {
       assertEquals(0, count.get());
       assertEquals(0, reporter.results.size());
       assertEquals(1, reporter.exceptions.size());
     } else {
       assertEquals(1, count.get());
       assertEquals(0, reporter.exceptions.size());
       assertEquals(2, reporter.results.size());
       assertEquals("my_test_1", reporter.results.get(0).name());
       assertTrue(reporter.results.get(0).failed());
       assertEquals("my_test_2", reporter.results.get(1).name());
       assertTrue(reporter.results.get(1).succeeded());
     }
   }
 }
Пример #20
0
 @Test
 public void runTestWithAsyncFailure() throws Exception {
   BlockingQueue<TestContext> queue = new ArrayBlockingQueue<>(1);
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 context.async();
                 queue.add(context);
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   assertFalse(reporter.completed());
   TestContext test = queue.poll(2, TimeUnit.SECONDS);
   try {
     test.fail("the_message");
   } catch (AssertionError ignore) {
   }
   reporter.await();
   assertTrue(reporter.completed());
 }
Пример #21
0
 @Test
 public void testAttributesOperations() throws Exception {
   TestSuite suite =
       TestSuite.create("my_suite")
           .test(
               "my_test",
               context -> {
                 context.assertEquals(null, context.get("value"));
                 context.assertEquals(null, context.put("value", 4));
                 context.assertEquals(4, context.get("value"));
                 context.assertEquals(4, context.put("value", 5));
                 context.assertEquals(5, context.get("value"));
                 context.assertEquals(5, context.remove("value"));
                 context.assertEquals(null, context.get("value"));
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(0, reporter.exceptions.size());
   assertEquals(1, reporter.results.size());
   assertEquals("my_test", reporter.results.get(0).name());
   assertFalse(reporter.results.get(0).failed());
 }
Пример #22
0
 @Test
 public void testStringEcho() throws Throwable {
   run();
 }
 @Test(timeout = 30000)
 public void testConnectTimeout() throws Throwable {
   run();
 }
Пример #24
0
 @Test
 public void testStringEchoNotAutoRead() throws Throwable {
   run();
 }
Пример #25
0
 @Test
 public void testScopedAttributes() throws Exception {
   List<Integer> before = Collections.synchronizedList(new ArrayList<>());
   List<Integer> beforeEach = Collections.synchronizedList(new ArrayList<>());
   AtomicInteger count = new AtomicInteger();
   AtomicInteger test0 = new AtomicInteger(-1);
   AtomicInteger test1 = new AtomicInteger(-1);
   List<Integer> afterEach = Collections.synchronizedList(new ArrayList<>());
   List<Integer> after = Collections.synchronizedList(new ArrayList<>());
   TestSuite suite =
       TestSuite.create("my_suite")
           .before(
               context -> {
                 Integer value = context.get("value");
                 if (value != null) {
                   before.add(value);
                 }
                 context.put("value", -10);
               })
           .beforeEach(
               context -> {
                 Integer value = context.get("value");
                 beforeEach.add(value);
                 context.put("value", count.getAndIncrement());
               })
           .test(
               "my_test0",
               context -> {
                 int value = context.get("value");
                 test0.set(value);
                 context.put("value", value * 2);
               })
           .test(
               "my_test1",
               context -> {
                 int value = context.get("value");
                 test1.set(context.get("value"));
                 context.put("value", value * 2);
               })
           .afterEach(
               context -> {
                 int value = context.get("value");
                 afterEach.add(value);
               })
           .after(
               context -> {
                 int value = context.get("value");
                 after.add(value);
               });
   TestReporter reporter = new TestReporter();
   run(suite, reporter);
   reporter.await();
   assertEquals(Arrays.<Integer>asList(), before);
   assertEquals(Arrays.<Integer>asList(-10, -10), beforeEach);
   assertEquals(0, test0.get());
   assertEquals(1, test1.get());
   assertEquals(Arrays.<Integer>asList(0, 2), afterEach);
   assertEquals(Arrays.<Integer>asList(-10), after);
   assertEquals(0, reporter.exceptions.size());
   assertEquals(2, reporter.results.size());
   assertEquals("my_test0", reporter.results.get(0).name());
   assertFalse(reporter.results.get(0).failed());
   assertEquals("my_test1", reporter.results.get(1).name());
   assertFalse(reporter.results.get(1).failed());
 }
 @Test(timeout = 30000)
 public void testSslRenegotiationRejected() throws Throwable {
   Assume.assumeTrue(OpenSsl.isAvailable());
   run();
 }
Пример #27
0
 public final boolean doSomeOperation() {
   run();
   return doSomething() > 0;
 }