This is an automated email from the ASF dual-hosted git repository.
kinow pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
The following commit(s) were added to refs/heads/master by this push:
new 115a6c6 StreamsTest junit-jupiter
115a6c6 is described below
commit 115a6c64bc6dad12edaf3c5deaac7bffa0fa3b86
Author: John Patrick <142304+nhojpatr...@users.noreply.github.com>
AuthorDate: Sun Mar 1 20:30:03 2020 +0000
StreamsTest junit-jupiter
---
.../java/org/apache/commons/lang3/StreamsTest.java | 170 +++++++++++----------
1 file changed, 92 insertions(+), 78 deletions(-)
diff --git a/src/test/java/org/apache/commons/lang3/StreamsTest.java
b/src/test/java/org/apache/commons/lang3/StreamsTest.java
index 0f618b6..a5985aa 100644
--- a/src/test/java/org/apache/commons/lang3/StreamsTest.java
+++ b/src/test/java/org/apache/commons/lang3/StreamsTest.java
@@ -16,27 +16,37 @@
*/
package org.apache.commons.lang3;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.DynamicTest.dynamicTest;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
import org.apache.commons.lang3.Functions.FailableConsumer;
import org.apache.commons.lang3.Functions.FailablePredicate;
+import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.function.Executable;
import org.xml.sax.SAXException;
class StreamsTest {
+
@Test
void testSimpleStreamMap() {
final List<String> input = Arrays.asList("1", "2", "3", "4", "5", "6");
- final List<Integer> output = Functions.stream(input).map(s ->
Integer.valueOf(s)).collect(Collectors.toList());
+ final List<Integer> output = Functions.stream(input).map((s) ->
Integer.valueOf(s)).collect(Collectors.toList());
assertEquals(6, output.size());
for (int i = 0; i < 6; i++) {
assertEquals(i+1, output.get(i).intValue());
@@ -46,19 +56,16 @@ class StreamsTest {
@Test
void testSimpleStreamMapFailing() {
final List<String> input = Arrays.asList("1", "2", "3", "4 ", "5",
"6");
- try {
- Functions.stream(input).map(s ->
Integer.valueOf(s)).collect(Collectors.toList());
- fail("Expected Exception");
- } catch (final NumberFormatException nfe) {
- assertEquals("For input string: \"4 \"", nfe.getMessage());
- }
+ final Executable testMethod = () -> Functions.stream(input).map((s) ->
Integer.valueOf(s)).collect(Collectors.toList());
+ final NumberFormatException thrown =
assertThrows(NumberFormatException.class, testMethod);
+ assertEquals("For input string: \"4 \"", thrown.getMessage());
}
@Test
void testSimpleStreamForEach() {
final List<String> input = Arrays.asList("1", "2", "3", "4", "5", "6");
final List<Integer> output = new ArrayList<>();
- Functions.stream(input).forEach(s -> output.add(Integer.valueOf(s)));
+ Functions.stream(input).forEach((s) -> output.add(Integer.valueOf(s)));
assertEquals(6, output.size());
for (int i = 0; i < 6; i++) {
assertEquals(i+1, output.get(i).intValue());
@@ -76,7 +83,7 @@ class StreamsTest {
}
protected <T extends Throwable> FailableConsumer<String, T>
asIntConsumer(final T pThrowable) {
- return s -> {
+ return (s) -> {
final Integer i = Integer.valueOf(s);
if (i.intValue() == 4) {
throw pThrowable;
@@ -84,41 +91,47 @@ class StreamsTest {
};
}
- @Test
- void testSimpleStreamForEachFailing() {
+ @TestFactory
+ Stream<DynamicTest> simpleStreamForEachFailing() {
final List<String> input = Arrays.asList("1", "2", "3", "4", "5", "6");
- final List<Integer> output = new ArrayList<>();
- final IllegalArgumentException ise = new
IllegalArgumentException("Invalid argument: 4");
- try {
- Functions.stream(input).forEach(asIntConsumer(ise));
- fail("Expected Exception");
- } catch (final IllegalArgumentException e) {
- assertSame(ise, e);
- }
- output.clear();
- final OutOfMemoryError oome = new OutOfMemoryError();
- try {
- Functions.stream(input).forEach(asIntConsumer(oome));
- fail("Expected Exception");
- } catch (final Throwable t) {
- assertSame(oome, t);
- }
- output.clear();
- final SAXException se = new SAXException();
- try {
- Functions.stream(input).forEach(asIntConsumer(se));
- fail("Expected Exception");
- } catch (final UndeclaredThrowableException ute) {
- assertSame(se, ute.getCause());
- }
+
+ return Stream.of(
+
+ dynamicTest("IllegalArgumentException", () -> {
+ final IllegalArgumentException ise = new
IllegalArgumentException();
+ final Executable testMethod = () -> Functions.stream(input)
+ .forEach(asIntConsumer(ise));
+ final IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, testMethod);
+ assertThat(thrown.getMessage(), is(nullValue()));
+ }),
+
+ dynamicTest("OutOfMemoryError", () -> {
+ final OutOfMemoryError oome = new OutOfMemoryError();
+ final Executable oomeTestMethod = () ->
Functions.stream(input)
+ .forEach(asIntConsumer(oome));
+ final OutOfMemoryError oomeThrown =
assertThrows(OutOfMemoryError.class, oomeTestMethod);
+ assertThat(oomeThrown.getMessage(), is(nullValue()));
+ }),
+
+ dynamicTest("SAXException", () -> {
+ final SAXException se = new SAXException();
+ final Executable seTestMethod = () ->
Functions.stream(input)
+ .forEach(asIntConsumer(se));
+ final UndeclaredThrowableException seThrown =
assertThrows(UndeclaredThrowableException.class, seTestMethod);
+ assertAll(
+ () -> assertThat(seThrown.getMessage(),
is(nullValue())),
+ () -> assertThat(seThrown.getCause(),
is(equalTo(se)))
+ );
+ })
+ );
}
@Test
void testSimpleStreamFilter() {
final List<String> input = Arrays.asList("1", "2", "3", "4", "5", "6");
final List<Integer> output = Functions.stream(input)
- .map(s -> Integer.valueOf(s))
- .filter(i -> {
+ .map((s) -> Integer.valueOf(s))
+ .filter((i) -> {
return i.intValue() %2 == 0;
})
.collect(Collectors.toList());
@@ -133,7 +146,7 @@ class StreamsTest {
}
protected <T extends Throwable> FailablePredicate<Integer, T>
asIntPredicate(final T pThrowable) {
- return i -> {
+ return (i) -> {
if (i.intValue() == 5) {
if (pThrowable != null) {
throw pThrowable;
@@ -143,49 +156,50 @@ class StreamsTest {
};
}
- @Test
- void testSimpleStreamFilterFailing() {
+ @TestFactory
+ Stream<DynamicTest> simpleStreamFilterFailing() {
final List<String> input = Arrays.asList("1", "2", "3", "4", "5", "6");
final List<Integer> output = Functions.stream(input)
- .map(s -> Integer.valueOf(s))
+ .map((s) -> Integer.valueOf(s))
.filter(asIntPredicate(null))
.collect(Collectors.toList());
assertEvenNumbers(output);
- output.clear();
- final IllegalArgumentException iae = new
IllegalArgumentException("Invalid argument: " + 5);
- try {
- Functions.stream(input)
- .map(s -> Integer.valueOf(s))
- .filter(asIntPredicate(iae))
- .collect(Collectors.toList());
- fail("Expected Exception");
- } catch (final IllegalArgumentException e) {
- assertSame(iae, e);
- }
-
- output.clear();
- final OutOfMemoryError oome = new OutOfMemoryError();
- try {
- Functions.stream(input)
- .map(s -> Integer.valueOf(s))
- .filter(asIntPredicate(oome))
- .collect(Collectors.toList());
- fail("Expected Exception");
- } catch (final Throwable t) {
- assertSame(oome, t);
- }
-
- output.clear();
- final SAXException se = new SAXException();
- try {
- Functions.stream(input)
- .map(s -> Integer.valueOf(s))
- .filter(asIntPredicate(se))
- .collect(Collectors.toList());
- fail("Expected Exception");
- } catch (final UndeclaredThrowableException t) {
- assertSame(se, t.getCause());
- }
+ return Stream.of(
+
+ dynamicTest("IllegalArgumentException", () -> {
+ final IllegalArgumentException iae = new
IllegalArgumentException("Invalid argument: " + 5);
+ final Executable testMethod = () -> Functions.stream(input)
+ .map((s) -> Integer.valueOf(s))
+ .filter(asIntPredicate(iae))
+ .collect(Collectors.toList());
+ final IllegalArgumentException thrown =
assertThrows(IllegalArgumentException.class, testMethod);
+ assertThat(thrown.getMessage(), is(equalTo("Invalid
argument: " + 5)));
+ }),
+
+ dynamicTest("OutOfMemoryError", () -> {
+ final OutOfMemoryError oome = new OutOfMemoryError();
+ final Executable testMethod = () -> Functions.stream(input)
+ .map((s) -> Integer.valueOf(s))
+ .filter(asIntPredicate(oome))
+ .collect(Collectors.toList());
+ final OutOfMemoryError thrown =
assertThrows(OutOfMemoryError.class, testMethod);
+ assertThat(thrown.getMessage(), is(nullValue()));
+ }),
+
+ dynamicTest("SAXException", () -> {
+ final SAXException se = new SAXException();
+ final Executable testMethod = () -> Functions.stream(input)
+ .map((s) -> Integer.valueOf(s))
+ .filter(asIntPredicate(se))
+ .collect(Collectors.toList());
+ final UndeclaredThrowableException thrown =
assertThrows(UndeclaredThrowableException.class, testMethod);
+ assertAll(
+ () -> assertThat(thrown.getMessage(),
is(nullValue())),
+ () -> assertThat(thrown.getCause(),
is(equalTo(se)))
+ );
+ })
+ );
}
+
}
