Refine search
@Test public void stateWithFalseExpressionAndMessageSupplier() { thrown.expect(IllegalStateException.class); thrown.expectMessage("enigma"); Assert.state(false, () -> "enigma"); }
@Test public void invalidPayloadType() throws JMSException { MessagingMessageListenerAdapter listener = createDefaultInstance(Integer.class); Session session = mock(Session.class); this.thrown.expect(ListenerExecutionFailedException.class); this.thrown.expectCause(Matchers.isA(MessageConversionException.class)); this.thrown.expectMessage(getDefaultListenerMethod(Integer.class).toGenericString()); // ref to method listener.onMessage(createSimpleJmsTextMessage("test"), session); // test is not a valid integer }
@Test public void testAssertNotMatchCount() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(); oi.subscribe(subscriber); thrown.expect(AssertionError.class); // FIXME different message format // thrown.expectMessage("Number of items does not match. Provided: 1 Actual: 2"); subscriber.assertValue(1); subscriber.assertValueCount(2); subscriber.assertTerminated(); }
@Test public void hasLengthWithNull() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma"); Assert.hasLength(null, "enigma"); }
@Test public void testAssertNotMatchValue() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); oi.subscribe(ts); thrown.expect(AssertionError.class); // FIXME different message pattern // thrown.expectMessage("Value at index: 1 expected to be [3] (Integer) but was: [2] (Integer)"); ts.assertValues(1, 3); ts.assertValueCount(2); ts.assertTerminated(); }
@Test public void hasLengthWithNullAndMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma"); Assert.hasLength(null, () -> "enigma"); }
@Test public void testAssertNotMatchCount() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); oi.subscribe(ts); thrown.expect(AssertionError.class); // FIXME different message pattern // thrown.expectMessage("Number of items does not match. Provided: 1 Actual: 2"); ts.assertValues(1); ts.assertValueCount(2); ts.assertTerminated(); }
@Test public void notEmptyArrayWithNullArrayAndMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma"); Assert.notEmpty((Object[]) null, () -> "enigma"); }
@Test public void testAssertNotMatchValue() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(); oi.subscribe(subscriber); thrown.expect(AssertionError.class); // FIXME different message format // thrown.expectMessage("Value at index: 1 expected to be [3] (Integer) but was: [2] (Integer)"); subscriber.assertValues(1, 3); subscriber.assertValueCount(2); subscriber.assertTerminated(); }
@Test public void notEmptyMapWithNullMap() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma"); Assert.notEmpty((Map<?, ?>) null, "enigma"); }
@Test public void assertNeverAtMatchingValue() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> subscriber = new TestSubscriber<Integer>(); oi.subscribe(subscriber); subscriber.assertValues(1, 2); thrown.expect(AssertionError.class); subscriber.assertNever(2); subscriber.assertValueCount(2); subscriber.assertTerminated(); }
@Test public void isInstanceOfWithNullType() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Type to check against must not be null"); Assert.isInstanceOf(null, "foo", "enigma"); }
@Test public void assertNeverAtMatchingValue() { Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2)); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); oi.subscribe(ts); ts.assertValues(1, 2); thrown.expect(AssertionError.class); ts.assertNever(2); ts.assertValueCount(2); ts.assertTerminated(); }
@Test public void isInstanceOfWithTypeMismatchAndCustomMessage() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Custom message: java.lang.Long"); Assert.isInstanceOf(String.class, 42L, "Custom message"); }
@Test public void isInstanceOfWithTypeMismatchAndCustomMessageWithSpace() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Custom message for java.lang.Long"); Assert.isInstanceOf(String.class, 42L, "Custom message for "); }
@Test public void isInstanceOfWithNullInstanceAndMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma: null"); Assert.isInstanceOf(String.class, null, () -> "enigma"); }
@Test public void isInstanceOfWithTypeMismatchAndNullMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Object of class [java.lang.Long] must be an instance of class java.lang.String"); Assert.isInstanceOf(String.class, 42L, (Supplier<String>) null); }
@Test public void isInstanceOfWithTypeMismatchAndMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("enigma: java.lang.Long"); Assert.isInstanceOf(String.class, 42L, () -> "enigma"); }
@Test @SuppressWarnings("resource") public void testPackagePrivateExtensionCantBeExposed() { this.thrown.expect(InvalidMetadataException.class); this.thrown.expectMessage(PackagePrivateTestBean.class.getName()); this.thrown.expectMessage("must be public"); new AnnotationConfigApplicationContext(PackagePrivateConfiguration.class); }
@Test public void hasTextWithNullAndNullMessageSupplier() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage(equalTo(null)); Assert.hasText(null, (Supplier<String>) null); }