/*
   * @see DATAREDIS-415
   */
  @Test
  public void interruptAtStart() throws Exception {

    final Thread main = Thread.currentThread();

    // interrupt thread once Executor.execute is called
    doAnswer(
            new Answer<Object>() {

              @Override
              public Object answer(final InvocationOnMock invocationOnMock) throws Throwable {

                main.interrupt();
                return null;
              }
            })
        .when(executorMock)
        .execute(any(Runnable.class));

    container.addMessageListener(adapter, new ChannelTopic("a"));
    container.start();

    // reset the interrupted flag to not destroy the teardown
    assertThat(Thread.interrupted(), is(true));

    assertThat(container.isRunning(), is(false));
  }
    @Override
    public Subscription onSubscribe(final Observer<? super String> observer) {
      System.out.println("TestObservable subscribed to ...");
      t =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  try {
                    System.out.println("running TestObservable thread");
                    for (String s : values) {
                      if ("fail".equals(s)) throw new RuntimeException("Forced Failure");
                      System.out.println("TestObservable onNext: " + s);
                      observer.onNext(s);
                    }
                    System.out.println("TestObservable onCompleted");
                    observer.onCompleted();
                  } catch (Throwable e) {
                    System.out.println("TestObservable onError: " + e);
                    observer.onError(e);
                  }
                }
              });
      System.out.println("starting TestObservable thread");
      t.start();
      System.out.println("done starting TestObservable thread");
      return s;
    }
Ejemplo n.º 3
0
      @Override
      public Subscription subscribe(final Observer<String> observer) {
        System.out.println("TestObservable subscribed to ...");
        t =
            new Thread(
                new Runnable() {

                  @Override
                  public void run() {
                    try {
                      System.out.println("running TestObservable thread");
                      for (String s : values) {
                        System.out.println("TestObservable onNext: " + s);
                        observer.onNext(s);
                      }
                      observer.onCompleted();
                    } catch (Exception e) {
                      throw new RuntimeException(e);
                    }
                  }
                });
        System.out.println("starting TestObservable thread");
        t.start();
        System.out.println("done starting TestObservable thread");
        return s;
      }
    @Override
    public void subscribe(final Subscriber<? super String> observer) {
      observer.onSubscribe(EmptySubscription.INSTANCE);
      t =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  for (String s : valuesToReturn) {
                    if (s == null) {
                      System.out.println("throwing exception");
                      try {
                        Thread.sleep(100);
                      } catch (Throwable e) {

                      }
                      observer.onError(new NullPointerException());
                      return;
                    } else {
                      observer.onNext(s);
                    }
                  }
                  System.out.println("subscription complete");
                  observer.onComplete();
                }
              });
      t.start();
    }
 @Test
 public void testCreateLDAPConnectionFactoryWithCustomClassLoader() throws Exception {
   // test no exception is thrown, which means transport provider is correctly loaded
   LDAPOptions options =
       new LDAPOptions().setProviderClassLoader(Thread.currentThread().getContextClassLoader());
   InetSocketAddress socketAddress = findFreeSocketAddress();
   LDAPConnectionFactory factory =
       new LDAPConnectionFactory(socketAddress.getHostName(), socketAddress.getPort(), options);
   factory.close();
 }
    @Override
    public void subscribe(final Subscriber<? super String> observer) {
      observer.onSubscribe(EmptySubscription.INSTANCE);
      t =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  observer.onNext("hello");
                  observer.onComplete();
                }
              });
      t.start();
    }
    @Override
    public void subscribe(final Subscriber<? super String> observer) {
      observer.onSubscribe(EmptySubscription.INSTANCE);
      t =
          new Thread(
              new Runnable() {

                @Override
                public void run() {
                  try {
                    Thread.sleep(100);
                  } catch (InterruptedException e) {
                    observer.onError(e);
                  }
                  observer.onNext("hello");
                  observer.onComplete();
                }
              });
      t.start();
    }
Ejemplo n.º 8
0
      @Override
      public Subscription subscribe(final Observer<String> observer) {
        t =
            new Thread(
                new Runnable() {

                  @Override
                  public void run() {
                    onNextBeingSent.countDown();
                    observer.onNext("hello");
                    // I can't use a countDownLatch to prove we are actually sending 'onNext'
                    // since it will block if synchronized and I'll deadlock
                    observer.onCompleted();
                  }
                });
        t.start();

        return new Subscription() {

          @Override
          public void unsubscribe() {}
        };
      }
Ejemplo n.º 9
0
    @Test
    public void testSynchronizationOfMultipleSequences() throws Exception {
      final TestASynchronousObservable o1 = new TestASynchronousObservable();
      final TestASynchronousObservable o2 = new TestASynchronousObservable();

      // use this latch to cause onNext to wait until we're ready to let it go
      final CountDownLatch endLatch = new CountDownLatch(1);

      final AtomicInteger concurrentCounter = new AtomicInteger();
      final AtomicInteger totalCounter = new AtomicInteger();

      @SuppressWarnings("unchecked")
      Observable<String> m = Observable.create(merge(o1, o2));
      m.subscribe(
          new Observer<String>() {

            @Override
            public void onCompleted() {}

            @Override
            public void onError(Exception e) {
              throw new RuntimeException("failed", e);
            }

            @Override
            public void onNext(String v) {
              totalCounter.incrementAndGet();
              concurrentCounter.incrementAndGet();
              try {
                // wait here until we're done asserting
                endLatch.await();
              } catch (InterruptedException e) {
                e.printStackTrace();
                throw new RuntimeException("failed", e);
              } finally {
                concurrentCounter.decrementAndGet();
              }
            }
          });

      // wait for both observables to send (one should be blocked)
      o1.onNextBeingSent.await();
      o2.onNextBeingSent.await();

      // I can't think of a way to know for sure that both threads have or are trying to send onNext
      // since I can't use a CountDownLatch for "after" onNext since I want to catch during it
      // but I can't know for sure onNext is invoked
      // so I'm unfortunately reverting to using a Thread.sleep to allow the process scheduler time
      // to make sure after o1.onNextBeingSent and o2.onNextBeingSent are hit that the following
      // onNext is invoked.

      Thread.sleep(300);

      try { // in try/finally so threads are released via latch countDown even if assertion fails
        assertEquals(1, concurrentCounter.get());
      } finally {
        // release so it can finish
        endLatch.countDown();
      }

      try {
        o1.t.join();
        o2.t.join();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }

      assertEquals(2, totalCounter.get());
      assertEquals(0, concurrentCounter.get());
    }