improve tests

Author: fmbenhassine

src/test/java/io/github/benas/unixstream/PredicatesTest.java

@@ -0,0 +1,63 @@
+package io.github.benas.unixstream;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PredicatesTest {
+
+    @Test
+    public void nonNull() throws Exception {
+        assertThat(Predicates.nonNull().test(1)).isTrue();
+        assertThat(Predicates.nonNull().test(null)).isFalse();
+    }
+
+    @Test
+    public void isNull() throws Exception {
+        assertThat(Predicates.isNull().test(1)).isFalse();
+        assertThat(Predicates.isNull().test(null)).isTrue();
+    }
+
+    @Test
+    public void empty() throws Exception {
+        assertThat(Predicates.empty().test("")).isTrue();
+        assertThat(Predicates.empty().test("a")).isFalse();
+    }
+
+    @Test
+    public void startsWith() throws Exception {
+        assertThat(Predicates.startsWith("a").test("ab")).isTrue();
+        assertThat(Predicates.startsWith("a").test("cd")).isFalse();
+    }
+
+    @Test
+    public void endsWith() throws Exception {
+        assertThat(Predicates.endsWith("b").test("ab")).isTrue();
+        assertThat(Predicates.endsWith("b").test("cd")).isFalse();
+    }
+
+    @Test
+    public void matches() throws Exception {
+        assertThat(Predicates.matches("a*").test("aa")).isTrue();
+        assertThat(Predicates.matches("a*").test("bb")).isFalse();
+    }
+
+    @Test
+    public void even() throws Exception {
+        assertThat(Predicates.even().test(2)).isTrue();
+        assertThat(Predicates.even().test(1)).isFalse();
+    }
+
+    @Test
+    public void odd() throws Exception {
+        assertThat(Predicates.odd().test(1)).isTrue();
+        assertThat(Predicates.odd().test(2)).isFalse();
+    }
+
+    @Test
+    public void isZero() throws Exception {
+        assertThat(Predicates.isZero().test(0)).isTrue();
+        assertThat(Predicates.isZero().test(1)).isFalse();
+    }
+
+}

src/test/java/io/github/benas/unixstream/UnixStreamImplTest.java

@@ -62,4 +62,8 @@ public void integrationTest3() throws IOException {
         assertThat(items).isNotNull().isNotEmpty().hasSize(2).containsExactly("name", "bar");
     }
 
+    @Test
+    public void getShouldReturnTheOriginalStream() throws Exception {
+        assertThat(UnixStream.unixify(stream).get()).isEqualTo(stream);
+    }
 }

src/test/java/io/github/benas/unixstream/components/CatTest.java

@@ -0,0 +1,21 @@
+package io.github.benas.unixstream.components;
+
+import io.github.benas.unixstream.UnixStream;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CatTest {
+
+    private static final String TEST_RESOURCES_DIRECTORY = "src/test/resources";
+
+    @Test
+    public void cat() throws IOException {
+        UnixStream<String> unixStream = UnixStream.cat(Paths.get(TEST_RESOURCES_DIRECTORY, "input.txt"));
+
+        assertThat(unixStream).containsExactly("1,foo", "2,bar");
+    }
+}

src/test/java/io/github/benas/unixstream/components/CompactTest.java

@@ -1,12 +1,14 @@
 package io.github.benas.unixstream.components;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import io.github.benas.unixstream.UnixStream;
+import org.junit.Before;
+import org.junit.Test;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.junit.Before;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class CompactTest {
 
@@ -23,7 +25,14 @@ public void setUp() {
     @org.junit.Test
     public void apply() {
         List<String> strings = compact.apply(stream).collect(Collectors.toList());
-        
-        assertThat(strings).isNotEmpty().isEqualTo(Arrays.asList("ab", "cd"));
+
+        assertThat(strings).containsExactly("ab", "cd");
+    }
+
+    @Test
+    public void compact() throws Exception {
+        UnixStream<String> unixStream = UnixStream.from(Stream.of(" f o o ")).compact();
+
+        assertThat(unixStream).containsExactly("foo");
     }
 }

src/test/java/io/github/benas/unixstream/components/ConcatTest.java

@@ -1,5 +1,6 @@
 package io.github.benas.unixstream.components;
 
+import io.github.benas.unixstream.UnixStream;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -22,9 +23,29 @@ public void setUp() throws Exception {
     }
 
     @Test
-    public void testApply() throws Exception {
+    public void apply() throws Exception {
         List<String> strings = concat.apply(stream).collect(Collectors.toList());
 
-        assertThat(strings).isNotEmpty().hasSize(4).containsExactly("a", "b", "c", "d");
+        assertThat(strings).containsExactly("a", "b", "c", "d");
+    }
+
+    @Test
+    public void concatWithAnotherStream() throws Exception {
+        Stream<String> stream1 = Stream.of("foo");
+        Stream<String> stream2 = Stream.of("bar");
+
+        UnixStream<String> stream = UnixStream.unixify(stream1).concat(stream2);
+
+        assertThat(stream).containsExactly("foo", "bar");
+    }
+
+    @Test
+    public void concatTwoStreams() throws Exception {
+        Stream<String> stream1 = Stream.of("foo");
+        Stream<String> stream2 = Stream.of("bar");
+
+        UnixStream<String> stream = UnixStream.concat(stream1, stream2);
+
+        assertThat(stream).containsExactly("foo", "bar");
     }
 }

src/test/java/io/github/benas/unixstream/components/CutTest.java

@@ -1,5 +1,6 @@
 package io.github.benas.unixstream.components;
 
+import io.github.benas.unixstream.UnixStream;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -35,15 +36,21 @@ public void create_whenFiledIsLessThanOne() {
     public void apply() {
         List<String> strings = cut.apply(stream).collect(Collectors.toList());
 
-        assertThat(strings).isNotEmpty().hasSize(2).containsExactly("b", "d");
+        assertThat(strings).containsExactly("b", "d");
     }
 
     @Test
     public void apply_whenFieldIsOutOfRange() {
         cut = Cut.cut(";", 3);
         List<String> strings = cut.apply(stream).collect(Collectors.toList());
 
-        assertThat(strings).isNotEmpty().hasSize(2).containsExactly("", "");
+        assertThat(strings).containsExactly("", "");
     }
 
+    @Test
+    public void cut() throws Exception {
+        UnixStream<String> unixStream = UnixStream.unixify(stream).cut(";", 2);
+        
+        assertThat(unixStream).containsExactly("b", "d");
+    }
 }

src/test/java/io/github/benas/unixstream/components/Dos2UnixTest.java

@@ -1,12 +1,14 @@
 package io.github.benas.unixstream.components;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import io.github.benas.unixstream.UnixStream;
+import org.junit.Before;
+import org.junit.Test;
 
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.junit.Before;
-import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class Dos2UnixTest {
 
@@ -24,6 +26,13 @@ public void setUp() {
     public void apply() {
         List<String> strings = dos2Unix.apply(stream).collect(Collectors.toList());
 
-        assertThat(strings).isNotEmpty().hasSize(2).containsExactly("a\n", "b\nc\n");
+        assertThat(strings).containsExactly("a\n", "b\nc\n");
+    }
+
+    @Test
+    public void dos2unix() throws Exception {
+        UnixStream<String> unixStream = UnixStream.unixify(stream).dos2unix();
+
+        assertThat(unixStream).containsExactly("a\n", "b\nc\n");
     }
 }

src/test/java/io/github/benas/unixstream/components/EchoTest.java

@@ -0,0 +1,18 @@
+package io.github.benas.unixstream.components;
+
+import io.github.benas.unixstream.UnixStream;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class EchoTest {
+
+    @Test
+    public void echo() throws IOException {
+        UnixStream<String> stream = UnixStream.echo("hello");
+
+        assertThat(stream).containsExactly("hello");
+    }
+}

src/test/java/io/github/benas/unixstream/components/ExcludeTest.java

@@ -1,5 +1,7 @@
 package io.github.benas.unixstream.components;
 
+import io.github.benas.unixstream.Predicates;
+import io.github.benas.unixstream.UnixStream;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -28,4 +30,11 @@ public void apply() {
 
         assertThat(strings).isNotEmpty().hasSize(1).containsExactly("bc");
     }
+
+    @Test
+    public void exclude() throws Exception {
+        UnixStream<String> unixStream = UnixStream.from(stream).exclude(Predicates.contains("a"));
+
+        assertThat(unixStream).containsExactly("bc");
+    }
 }

src/test/java/io/github/benas/unixstream/components/ExpandTest.java

@@ -1,12 +1,14 @@
 package io.github.benas.unixstream.components;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import io.github.benas.unixstream.UnixStream;
+import org.junit.Before;
+import org.junit.Test;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import org.junit.Before;
+
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ExpandTest {
 
@@ -21,10 +23,17 @@ public void setUp() {
 
     }
 
-    @org.junit.Test
+    @Test
     public void apply() {
         List<String> strings = expand.apply(stream).collect(Collectors.toList());
-        
-        assertThat(strings).isNotEmpty().isEqualTo(Arrays.asList("a b", "c  d"));
+
+        assertThat(strings).containsExactly("a b", "c  d");
+    }
+
+    @Test
+    public void expand() throws Exception {
+        UnixStream<String> unixStream = UnixStream.from(stream).expand();
+
+        assertThat(unixStream).containsExactly("a b", "c  d");
     }
 }