How to use

contains

method

in

java.lang.String

/**
 * Returns true if {@code e} is due to a firmware bug fixed after Android 4.2.2.
 * https://code.google.com/p/android/issues/detail?id=54072
 */
public static boolean isAndroidGetsocknameError(AssertionError e) {
 return e.getCause() != null && e.getMessage() != null
   && e.getMessage().contains("getsockname failed");
}

  @Override
  public boolean test(Throwable t) {
    return t.getMessage() != null && t.getMessage().contains("Forced");
  }
});

  @Override
  public String apply(Integer t) throws Exception {
    String name = Thread.currentThread().getName();
    if (name.contains("RxSingleScheduler")) {
      return "RxSingleScheduler";
    }
    return name;
  }
})

  @Override
  public boolean test(Throwable t) throws Exception {
    return t.getMessage() != null && t.getMessage().contains("Forced");
  }
});

  @Override
  public void subscribe(MaybeEmitter<Object> emitter) throws Exception {
    assertTrue(emitter.toString().contains(MaybeCreate.Emitter.class.getSimpleName()));
  }
}).test().assertEmpty();

  @Override
  public void subscribe(SingleEmitter<Object> emitter) throws Exception {
    assertTrue(emitter.toString().contains(SingleCreate.Emitter.class.getSimpleName()));
  }
}).test().assertEmpty();

/**
 * This hijacks the Throwable.printStackTrace() output and puts it in a string, where we can look for
 * "CIRCULAR REFERENCE" (a String added by Throwable.printEnclosedStackTrace)
 */
private static void assertNoCircularReferences(Throwable ex) {
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  PrintStream printStream = new PrintStream(baos);
  ex.printStackTrace(printStream);
  assertFalse(baos.toString().contains("CIRCULAR REFERENCE"));
}

  @Override
  public void subscribe(CompletableEmitter emitter) throws Exception {
    assertTrue(emitter.toString().contains(CompletableCreate.Emitter.class.getSimpleName()));
  }
}).test().assertEmpty();

  @Override
  public void subscribe(FlowableEmitter<Object> emitter) throws Exception {
    assertTrue(emitter.toString().contains(entry.getValue().getSimpleName()));
    assertTrue(emitter.serialize().toString().contains(entry.getValue().getSimpleName()));
  }
}, entry.getKey()).test().assertEmpty();

  @Override
  public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
    assertTrue(emitter.toString().contains(ObservableCreate.CreateEmitter.class.getSimpleName()));
    assertTrue(emitter.serialize().toString().contains(ObservableCreate.CreateEmitter.class.getSimpleName()));
  }
}).test().assertEmpty();

    @Override
    public void onError(Throwable e) {
      String trace = stackTraceAsString(e);
      System.out.println("On Error: " + trace);

      assertTrue(trace, trace.contains("OnNextValue"));

      assertTrue("No Cause on throwable" + e, e.getCause() != null);
//            assertTrue(e.getCause().getClass().getSimpleName() + " no OnNextValue",
//                    e.getCause() instanceof OnErrorThrowable.OnNextValue);
    }

@Test
public void testOnErrorNotImplementedIsThrown() {
  List<Throwable> errors = TestHelper.trackPluginErrors();
  Observable.just(1, 2, 3).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer t1) {
      throw new RuntimeException("hello");
    }
  });
  TestHelper.assertError(errors, 0, RuntimeException.class);
  assertTrue(errors.get(0).toString(), errors.get(0).getMessage().contains("hello"));
  RxJavaPlugins.reset();
}

@Test
public void disposeIndicated() {
  TestSubscriber<Object> ts = new TestSubscriber<Object>();
  ts.cancel();
  try {
    ts.assertResult(1);
    throw new RuntimeException("Should have thrown!");
  } catch (Throwable ex) {
    assertTrue(ex.toString(), ex.toString().contains("disposed!"));
  }
}

@Test
public void printStackTrace() {
  StringWriter sw = new StringWriter();
  PrintWriter pw = new PrintWriter(sw);
  new CompositeException(new TestException()).printStackTrace(pw);
  assertTrue(sw.toString().contains("TestException"));
}

public static String hostHeader(HttpUrl url, boolean includeDefaultPort) {
 String host = url.host().contains(":")
   ? "[" + url.host() + "]"
   : url.host();
 return includeDefaultPort || url.port() != HttpUrl.defaultPort(url.scheme())
   ? host + ":" + url.port()
   : host;
}

@Test
public void assertNoTimeout2() {
  try {
    Flowable.never()
    .test()
    .awaitCount(1, TestWaitStrategy.SLEEP_1MS, 50)
    .assertNoTimeout();
    throw new RuntimeException("Should have thrown!");
  } catch (AssertionError ex) {
    assertTrue(ex.toString(), ex.getMessage().contains("Timeout?!"));
  }
}

@Test
public void assertTimeout2() {
  try {
    Flowable.empty()
    .test()
    .awaitCount(1, TestWaitStrategy.SLEEP_1MS, 50)
    .assertTimeout();
    throw new RuntimeException("Should have thrown!");
  } catch (AssertionError ex) {
    assertTrue(ex.toString(), ex.getMessage().contains("No timeout?!"));
  }
}

@Test
public void timeoutIndicated() throws InterruptedException {
  Thread.interrupted(); // clear flag
  TestSubscriber<Object> ts = Flowable.never()
  .test();
  assertFalse(ts.await(1, TimeUnit.MILLISECONDS));
  try {
    ts.assertResult(1);
    throw new RuntimeException("Should have thrown!");
  } catch (AssertionError ex) {
    assertTrue(ex.toString(), ex.toString().contains("timeout!"));
  }
}

@Test
public void timeoutIndicated2() throws InterruptedException {
  try {
    Flowable.never()
    .test()
    .awaitDone(1, TimeUnit.MILLISECONDS)
    .assertResult(1);
    throw new RuntimeException("Should have thrown!");
  } catch (AssertionError ex) {
    assertTrue(ex.toString(), ex.toString().contains("timeout!"));
  }
}

@Test
public void timeoutIndicated3() throws InterruptedException {
  TestSubscriber<Object> ts = Flowable.never()
  .test();
  assertFalse(ts.awaitTerminalEvent(1, TimeUnit.MILLISECONDS));
  try {
    ts.assertResult(1);
    throw new RuntimeException("Should have thrown!");
  } catch (AssertionError ex) {
    assertTrue(ex.toString(), ex.toString().contains("timeout!"));
  }
}