From d1bc7d22cc8250d222d9d1da0c41fba4070eda60 Mon Sep 17 00:00:00 2001 From: DOHA Date: Thu, 2 Oct 2014 22:09:36 +0200 Subject: [PATCH 1/9] add TestReader to test Read from file --- .../java/org/baeldung/java/io/TestReader.java | 247 ++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 core-java/src/test/java/org/baeldung/java/io/TestReader.java diff --git a/core-java/src/test/java/org/baeldung/java/io/TestReader.java b/core-java/src/test/java/org/baeldung/java/io/TestReader.java new file mode 100644 index 0000000000..517eac9f67 --- /dev/null +++ b/core-java/src/test/java/org/baeldung/java/io/TestReader.java @@ -0,0 +1,247 @@ +package org.baeldung.java.io; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.io.BufferedOutputStream; +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.RandomAccessFile; +import java.io.SequenceInputStream; +import java.io.StreamTokenizer; +import java.nio.ByteBuffer; +import java.nio.channels.FileChannel; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Enumeration; +import java.util.Scanner; +import java.util.Vector; + +import org.junit.Test; + + +/* +MappedByteBuffer + + */ +public class TestReader { + + @Test + public void whenReadWithBufferedReader_thenCorrect() throws IOException { + final String str = "Hello world"; + + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.txt")); + final String currentLine = reader.readLine(); + reader.close(); + + assertEquals(str, currentLine); + } + + @Test + public void whenReadWithScanner_thenCorrect() throws IOException { + final String str = "Hello world 1 2,3,4"; + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final Scanner scanner = new Scanner(new File("src/test/resources/test_read.txt")); + scanner.useDelimiter(" "); + + assertTrue(scanner.hasNext()); + assertEquals("Hello", scanner.next()); + assertEquals("world", scanner.next()); + assertEquals(1, scanner.nextInt()); + + scanner.useDelimiter(",| "); + + assertTrue(scanner.hasNextInt()); + assertEquals(2, scanner.nextInt()); + assertEquals(3, scanner.nextInt()); + assertEquals(4, scanner.nextInt()); + + scanner.close(); + + } + + @Test + public void whenReadWithStreamTokenizer_thenCorrectTokens() throws IOException { + final String str = "Hello 1"; + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final FileReader reader = new FileReader("src/test/resources/test_read.txt"); + final StreamTokenizer tokenizer = new StreamTokenizer(reader); + + tokenizer.nextToken(); + assertEquals(StreamTokenizer.TT_WORD, tokenizer.ttype); + assertEquals("Hello", tokenizer.sval); + tokenizer.nextToken(); + assertEquals(StreamTokenizer.TT_NUMBER, tokenizer.ttype); + assertEquals(1, tokenizer.nval, 0.0000001); + + tokenizer.nextToken(); + assertEquals(StreamTokenizer.TT_EOF, tokenizer.ttype); + reader.close(); + } + + @Test + public void whenReadWithDataInputStream_thenCorrect() throws IOException { + final String value = "Hello"; + final DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("src/test/resources/test_read.txt"))); + outStream.writeUTF(value); + outStream.close(); + + String result; + final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read.txt")); + result = reader.readUTF(); + reader.close(); + + assertEquals(value, result); + } + + public void whenReadTwoFilesWithSequenceInputStream_thenCorrect() throws IOException { + final int value1 = 2000; + final int value2 = 5000; + FileOutputStream writer = new FileOutputStream("src/test/resources/test_read.txt"); + writer.write(value1); + writer.close(); + writer = new FileOutputStream("src/test/resources/test_read1.txt"); + writer.write(value2); + writer.close(); + + final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read.txt"); + final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read1.txt"); + + final SequenceInputStream sequence = new SequenceInputStream(stream1, stream2); + final DataInputStream reader = new DataInputStream(sequence); + + assertEquals(value1, reader.readInt()); + assertEquals(value2, reader.readInt()); + + reader.close(); + stream2.close(); + } + + @Test + public void whenReadAllFilesInFolder_thenCorrect() throws IOException { + + final File dir = new File("src/test/resources"); + final File[] allFiles = dir.listFiles(); + final int noOfFiles = allFiles.length; + + final Vector allStreams = new Vector(); + + for (int i = 0; i < noOfFiles; i++) { + allStreams.add(new FileInputStream(allFiles[i])); + } + + final Enumeration enu = allStreams.elements(); + final SequenceInputStream sequence = new SequenceInputStream(enu); + + final BufferedReader reader = new BufferedReader(new InputStreamReader(sequence)); + + String line = reader.readLine(); + while (line != null) { + line = reader.readLine(); + } + reader.close(); + sequence.close(); + } + + @Test + public void whenReadUTFEncodedFile_thenCorrect() throws IOException { + final String str = "青空"; + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read.txt"), "UTF-8")); + final String currentLine = reader.readLine(); + reader.close(); + + assertEquals(str, currentLine); + } + + @Test + public void whenReadFileContentsIntoString_thenCorrect() throws IOException { + final String str = "Hello world \n Test line \n"; + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.txt")); + final StringBuilder builder = new StringBuilder(); + String currentLine = reader.readLine(); + while (currentLine != null) { + builder.append(currentLine); + builder.append("\n"); + currentLine = reader.readLine(); + } + + reader.close(); + + assertEquals(str, builder.toString()); + } + + @Test + public void whenReadWithFileChannel_thenCorrect() throws IOException { + final String str = "Hello world"; + final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); + writer.write(str); + writer.close(); + + final RandomAccessFile reader = new RandomAccessFile("src/test/resources/test_read.txt", "r"); + final FileChannel channel = reader.getChannel(); + + int bufferSize = 1024; + if (bufferSize > channel.size()) + bufferSize = (int) channel.size(); + final ByteBuffer buff = ByteBuffer.allocate(bufferSize); + channel.read(buff); + buff.flip(); + assertEquals(str, new String(buff.array())); + channel.close(); + reader.close(); + } + + @Test + public void whenReadSmallFileJava7_thenCorrect() throws IOException { + final String str = "Hello world"; + + final Path path = Paths.get("src/test/resources/test_read.txt"); + final byte[] strToBytes = str.getBytes(); + Files.write(path, strToBytes); + + final String read = Files.readAllLines(path).get(0); + assertEquals(str, read); + } + + @Test + public void whenReadLargeFileJava7_thenCorrect() throws IOException { + final String str = "Hello world"; + + final Path path = Paths.get("src/test/resources/test_read.txt"); + final byte[] strToBytes = str.getBytes(); + Files.write(path, strToBytes); + + final BufferedReader reader = Files.newBufferedReader(path); + final String line = reader.readLine(); + assertEquals(str, line); + } + +} From 00b5f89e87ace110a3d060b67334b084fbf66e60 Mon Sep 17 00:00:00 2001 From: eugenp Date: Sun, 5 Oct 2014 17:27:27 +0300 Subject: [PATCH 2/9] minor cleanup in java tests --- core-java/pom.xml | 2 +- .../test/java/org/baeldung/java/CoreJavaRandomUnitTest.java | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/core-java/pom.xml b/core-java/pom.xml index 294364d22c..a96da6761f 100644 --- a/core-java/pom.xml +++ b/core-java/pom.xml @@ -163,7 +163,7 @@ 5.1.2.Final - 17.0 + 17.0 3.3.2 diff --git a/core-java/src/test/java/org/baeldung/java/CoreJavaRandomUnitTest.java b/core-java/src/test/java/org/baeldung/java/CoreJavaRandomUnitTest.java index 95cd1b7c50..2b688ecb10 100644 --- a/core-java/src/test/java/org/baeldung/java/CoreJavaRandomUnitTest.java +++ b/core-java/src/test/java/org/baeldung/java/CoreJavaRandomUnitTest.java @@ -1,5 +1,6 @@ package org.baeldung.java; +import java.nio.charset.Charset; import java.util.Random; import org.apache.commons.lang3.RandomStringUtils; @@ -151,7 +152,7 @@ public class CoreJavaRandomUnitTest { public void givenUsingPlainJava_whenGeneratingRandomStringUnbounded_thenCorrect() { final byte[] array = new byte[7]; // length is bounded by 7 new Random().nextBytes(array); - final String generatedString = new String(array); + final String generatedString = new String(array, Charset.forName("UTF-8")); System.out.println(generatedString); } @@ -166,7 +167,7 @@ public class CoreJavaRandomUnitTest { final int randomLimitedInt = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit)); buffer.append((char) randomLimitedInt); } - final String generatedString = new String(buffer); + final String generatedString = buffer.toString(); System.out.println(generatedString); } From ac8b5e38ae34eb5f7463734f484ce5e50b56111c Mon Sep 17 00:00:00 2001 From: DOHA Date: Mon, 6 Oct 2014 02:11:34 +0200 Subject: [PATCH 3/9] Modify JavaReadFromFileTest --- ...tReader.java => JavaReadFromFileTest.java} | 134 +++++------------- 1 file changed, 34 insertions(+), 100 deletions(-) rename core-java/src/test/java/org/baeldung/java/io/{TestReader.java => JavaReadFromFileTest.java} (55%) diff --git a/core-java/src/test/java/org/baeldung/java/io/TestReader.java b/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java similarity index 55% rename from core-java/src/test/java/org/baeldung/java/io/TestReader.java rename to core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java index 517eac9f67..5ad6959707 100644 --- a/core-java/src/test/java/org/baeldung/java/io/TestReader.java +++ b/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java @@ -3,16 +3,11 @@ package org.baeldung.java.io; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -import java.io.BufferedOutputStream; import java.io.BufferedReader; -import java.io.BufferedWriter; import java.io.DataInputStream; -import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; -import java.io.FileOutputStream; import java.io.FileReader; -import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.RandomAccessFile; @@ -23,9 +18,7 @@ import java.nio.channels.FileChannel; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.util.Enumeration; import java.util.Scanner; -import java.util.Vector; import org.junit.Test; @@ -34,31 +27,22 @@ import org.junit.Test; MappedByteBuffer */ -public class TestReader { +public class JavaReadFromFileTest { @Test public void whenReadWithBufferedReader_thenCorrect() throws IOException { - final String str = "Hello world"; - - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); + final String expected_value = "Hello world"; final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.txt")); final String currentLine = reader.readLine(); reader.close(); - assertEquals(str, currentLine); + assertEquals(expected_value, currentLine); } @Test public void whenReadWithScanner_thenCorrect() throws IOException { - final String str = "Hello world 1 2,3,4"; - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); - - final Scanner scanner = new Scanner(new File("src/test/resources/test_read.txt")); + final Scanner scanner = new Scanner(new File("src/test/resources/test_read1.txt")); scanner.useDelimiter(" "); assertTrue(scanner.hasNext()); @@ -66,6 +50,13 @@ public class TestReader { assertEquals("world", scanner.next()); assertEquals(1, scanner.nextInt()); + scanner.close(); + + } + + @Test + public void whenReadWithScannerTwoDelimiters_thenCorrect() throws IOException { + final Scanner scanner = new Scanner(new File("src/test/resources/test_read2.txt")); scanner.useDelimiter(",| "); assertTrue(scanner.hasNextInt()); @@ -74,17 +65,11 @@ public class TestReader { assertEquals(4, scanner.nextInt()); scanner.close(); - } @Test public void whenReadWithStreamTokenizer_thenCorrectTokens() throws IOException { - final String str = "Hello 1"; - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); - - final FileReader reader = new FileReader("src/test/resources/test_read.txt"); + final FileReader reader = new FileReader("src/test/resources/test_read3.txt"); final StreamTokenizer tokenizer = new StreamTokenizer(reader); tokenizer.nextToken(); @@ -101,90 +86,48 @@ public class TestReader { @Test public void whenReadWithDataInputStream_thenCorrect() throws IOException { - final String value = "Hello"; - final DataOutputStream outStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("src/test/resources/test_read.txt"))); - outStream.writeUTF(value); - outStream.close(); + final String expected_value = "Hello"; String result; - final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read.txt")); + final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read4.txt")); result = reader.readUTF(); reader.close(); - assertEquals(value, result); + assertEquals(expected_value, result); } public void whenReadTwoFilesWithSequenceInputStream_thenCorrect() throws IOException { - final int value1 = 2000; - final int value2 = 5000; - FileOutputStream writer = new FileOutputStream("src/test/resources/test_read.txt"); - writer.write(value1); - writer.close(); - writer = new FileOutputStream("src/test/resources/test_read1.txt"); - writer.write(value2); - writer.close(); + final int expected_value1 = 2000; + final int expected_value2 = 5000; - final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read.txt"); - final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read1.txt"); + final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read5.txt"); + final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read6.txt"); final SequenceInputStream sequence = new SequenceInputStream(stream1, stream2); final DataInputStream reader = new DataInputStream(sequence); - assertEquals(value1, reader.readInt()); - assertEquals(value2, reader.readInt()); + assertEquals(expected_value1, reader.readInt()); + assertEquals(expected_value2, reader.readInt()); reader.close(); stream2.close(); } - @Test - public void whenReadAllFilesInFolder_thenCorrect() throws IOException { - - final File dir = new File("src/test/resources"); - final File[] allFiles = dir.listFiles(); - final int noOfFiles = allFiles.length; - - final Vector allStreams = new Vector(); - - for (int i = 0; i < noOfFiles; i++) { - allStreams.add(new FileInputStream(allFiles[i])); - } - - final Enumeration enu = allStreams.elements(); - final SequenceInputStream sequence = new SequenceInputStream(enu); - - final BufferedReader reader = new BufferedReader(new InputStreamReader(sequence)); - - String line = reader.readLine(); - while (line != null) { - line = reader.readLine(); - } - reader.close(); - sequence.close(); - } @Test public void whenReadUTFEncodedFile_thenCorrect() throws IOException { - final String str = "青空"; - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); - - final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read.txt"), "UTF-8")); + final String expected_value = "青空"; + final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.txt"), "UTF-8")); final String currentLine = reader.readLine(); reader.close(); - assertEquals(str, currentLine); + assertEquals(expected_value, currentLine); } @Test public void whenReadFileContentsIntoString_thenCorrect() throws IOException { - final String str = "Hello world \n Test line \n"; - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); - - final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.txt")); + final String expected_value = "Hello world \n Test line \n"; + final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read8.txt")); final StringBuilder builder = new StringBuilder(); String currentLine = reader.readLine(); while (currentLine != null) { @@ -195,16 +138,12 @@ public class TestReader { reader.close(); - assertEquals(str, builder.toString()); + assertEquals(expected_value, builder.toString()); } @Test public void whenReadWithFileChannel_thenCorrect() throws IOException { - final String str = "Hello world"; - final BufferedWriter writer = new BufferedWriter(new FileWriter("src/test/resources/test_read.txt")); - writer.write(str); - writer.close(); - + final String expected_value = "Hello world"; final RandomAccessFile reader = new RandomAccessFile("src/test/resources/test_read.txt", "r"); final FileChannel channel = reader.getChannel(); @@ -214,34 +153,29 @@ public class TestReader { final ByteBuffer buff = ByteBuffer.allocate(bufferSize); channel.read(buff); buff.flip(); - assertEquals(str, new String(buff.array())); + assertEquals(expected_value, new String(buff.array())); channel.close(); reader.close(); } @Test public void whenReadSmallFileJava7_thenCorrect() throws IOException { - final String str = "Hello world"; - + final String expected_value = "Hello world"; final Path path = Paths.get("src/test/resources/test_read.txt"); - final byte[] strToBytes = str.getBytes(); - Files.write(path, strToBytes); final String read = Files.readAllLines(path).get(0); - assertEquals(str, read); + assertEquals(expected_value, read); } @Test public void whenReadLargeFileJava7_thenCorrect() throws IOException { - final String str = "Hello world"; + final String expected_value = "Hello world"; final Path path = Paths.get("src/test/resources/test_read.txt"); - final byte[] strToBytes = str.getBytes(); - Files.write(path, strToBytes); - final BufferedReader reader = Files.newBufferedReader(path); final String line = reader.readLine(); - assertEquals(str, line); + assertEquals(expected_value, line); } + } From 357c71a96a3203a72324c96eac381e0719125de4 Mon Sep 17 00:00:00 2001 From: DOHA Date: Mon, 6 Oct 2014 09:28:15 +0200 Subject: [PATCH 4/9] Change input file extension Change input file extension from .txt to .in --- .../java/io/JavaReadFromFileTest.java | 24 +++++++++--------- core-java/src/test/resources/test_read.in | 1 + core-java/src/test/resources/test_read1.in | 1 + core-java/src/test/resources/test_read2.in | 1 + core-java/src/test/resources/test_read3.in | 1 + core-java/src/test/resources/test_read4.in | Bin 0 -> 7 bytes core-java/src/test/resources/test_read7.in | 1 + core-java/src/test/resources/test_read8.in | 2 ++ 8 files changed, 19 insertions(+), 12 deletions(-) create mode 100644 core-java/src/test/resources/test_read.in create mode 100644 core-java/src/test/resources/test_read1.in create mode 100644 core-java/src/test/resources/test_read2.in create mode 100644 core-java/src/test/resources/test_read3.in create mode 100644 core-java/src/test/resources/test_read4.in create mode 100644 core-java/src/test/resources/test_read7.in create mode 100644 core-java/src/test/resources/test_read8.in diff --git a/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java b/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java index 5ad6959707..72f658eb06 100644 --- a/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java +++ b/core-java/src/test/java/org/baeldung/java/io/JavaReadFromFileTest.java @@ -33,7 +33,7 @@ public class JavaReadFromFileTest { public void whenReadWithBufferedReader_thenCorrect() throws IOException { final String expected_value = "Hello world"; - final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.txt")); + final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read.in")); final String currentLine = reader.readLine(); reader.close(); @@ -42,7 +42,7 @@ public class JavaReadFromFileTest { @Test public void whenReadWithScanner_thenCorrect() throws IOException { - final Scanner scanner = new Scanner(new File("src/test/resources/test_read1.txt")); + final Scanner scanner = new Scanner(new File("src/test/resources/test_read1.in")); scanner.useDelimiter(" "); assertTrue(scanner.hasNext()); @@ -56,7 +56,7 @@ public class JavaReadFromFileTest { @Test public void whenReadWithScannerTwoDelimiters_thenCorrect() throws IOException { - final Scanner scanner = new Scanner(new File("src/test/resources/test_read2.txt")); + final Scanner scanner = new Scanner(new File("src/test/resources/test_read2.in")); scanner.useDelimiter(",| "); assertTrue(scanner.hasNextInt()); @@ -69,7 +69,7 @@ public class JavaReadFromFileTest { @Test public void whenReadWithStreamTokenizer_thenCorrectTokens() throws IOException { - final FileReader reader = new FileReader("src/test/resources/test_read3.txt"); + final FileReader reader = new FileReader("src/test/resources/test_read3.in"); final StreamTokenizer tokenizer = new StreamTokenizer(reader); tokenizer.nextToken(); @@ -89,7 +89,7 @@ public class JavaReadFromFileTest { final String expected_value = "Hello"; String result; - final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read4.txt")); + final DataInputStream reader = new DataInputStream(new FileInputStream("src/test/resources/test_read4.in")); result = reader.readUTF(); reader.close(); @@ -100,8 +100,8 @@ public class JavaReadFromFileTest { final int expected_value1 = 2000; final int expected_value2 = 5000; - final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read5.txt"); - final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read6.txt"); + final FileInputStream stream1 = new FileInputStream("src/test/resources/test_read5.in"); + final FileInputStream stream2 = new FileInputStream("src/test/resources/test_read6.in"); final SequenceInputStream sequence = new SequenceInputStream(stream1, stream2); final DataInputStream reader = new DataInputStream(sequence); @@ -117,7 +117,7 @@ public class JavaReadFromFileTest { @Test public void whenReadUTFEncodedFile_thenCorrect() throws IOException { final String expected_value = "青空"; - final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.txt"), "UTF-8")); + final BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("src/test/resources/test_read7.in"), "UTF-8")); final String currentLine = reader.readLine(); reader.close(); @@ -127,7 +127,7 @@ public class JavaReadFromFileTest { @Test public void whenReadFileContentsIntoString_thenCorrect() throws IOException { final String expected_value = "Hello world \n Test line \n"; - final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read8.txt")); + final BufferedReader reader = new BufferedReader(new FileReader("src/test/resources/test_read8.in")); final StringBuilder builder = new StringBuilder(); String currentLine = reader.readLine(); while (currentLine != null) { @@ -144,7 +144,7 @@ public class JavaReadFromFileTest { @Test public void whenReadWithFileChannel_thenCorrect() throws IOException { final String expected_value = "Hello world"; - final RandomAccessFile reader = new RandomAccessFile("src/test/resources/test_read.txt", "r"); + final RandomAccessFile reader = new RandomAccessFile("src/test/resources/test_read.in", "r"); final FileChannel channel = reader.getChannel(); int bufferSize = 1024; @@ -161,7 +161,7 @@ public class JavaReadFromFileTest { @Test public void whenReadSmallFileJava7_thenCorrect() throws IOException { final String expected_value = "Hello world"; - final Path path = Paths.get("src/test/resources/test_read.txt"); + final Path path = Paths.get("src/test/resources/test_read.in"); final String read = Files.readAllLines(path).get(0); assertEquals(expected_value, read); @@ -171,7 +171,7 @@ public class JavaReadFromFileTest { public void whenReadLargeFileJava7_thenCorrect() throws IOException { final String expected_value = "Hello world"; - final Path path = Paths.get("src/test/resources/test_read.txt"); + final Path path = Paths.get("src/test/resources/test_read.in"); final BufferedReader reader = Files.newBufferedReader(path); final String line = reader.readLine(); assertEquals(expected_value, line); diff --git a/core-java/src/test/resources/test_read.in b/core-java/src/test/resources/test_read.in new file mode 100644 index 0000000000..70c379b63f --- /dev/null +++ b/core-java/src/test/resources/test_read.in @@ -0,0 +1 @@ +Hello world \ No newline at end of file diff --git a/core-java/src/test/resources/test_read1.in b/core-java/src/test/resources/test_read1.in new file mode 100644 index 0000000000..1e46242993 --- /dev/null +++ b/core-java/src/test/resources/test_read1.in @@ -0,0 +1 @@ +Hello world 1 \ No newline at end of file diff --git a/core-java/src/test/resources/test_read2.in b/core-java/src/test/resources/test_read2.in new file mode 100644 index 0000000000..fe47dc003b --- /dev/null +++ b/core-java/src/test/resources/test_read2.in @@ -0,0 +1 @@ +2,3 4 \ No newline at end of file diff --git a/core-java/src/test/resources/test_read3.in b/core-java/src/test/resources/test_read3.in new file mode 100644 index 0000000000..db9f25a672 --- /dev/null +++ b/core-java/src/test/resources/test_read3.in @@ -0,0 +1 @@ +Hello 1 \ No newline at end of file diff --git a/core-java/src/test/resources/test_read4.in b/core-java/src/test/resources/test_read4.in new file mode 100644 index 0000000000000000000000000000000000000000..5727d54bfcb2046f4989fd13cf5dcf408201fa2a GIT binary patch literal 7 OcmZQz^+?Uh$p-)htO5D} literal 0 HcmV?d00001 diff --git a/core-java/src/test/resources/test_read7.in b/core-java/src/test/resources/test_read7.in new file mode 100644 index 0000000000..28d4d45d43 --- /dev/null +++ b/core-java/src/test/resources/test_read7.in @@ -0,0 +1 @@ +青空 \ No newline at end of file diff --git a/core-java/src/test/resources/test_read8.in b/core-java/src/test/resources/test_read8.in new file mode 100644 index 0000000000..10fc1aac8a --- /dev/null +++ b/core-java/src/test/resources/test_read8.in @@ -0,0 +1,2 @@ +Hello world + Test line From e243d2aed26503d0a2613990a462773598008082 Mon Sep 17 00:00:00 2001 From: DOHA Date: Wed, 8 Oct 2014 23:29:58 +0200 Subject: [PATCH 5/9] add class GuavaClassTest --- .../org/baeldung/guava/GuavaCacheTest.java | 238 ++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100644 guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java diff --git a/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java new file mode 100644 index 0000000000..df006498f4 --- /dev/null +++ b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java @@ -0,0 +1,238 @@ +package org.baeldung.guava; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +import org.junit.Test; + +import com.google.common.base.Optional; +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.cache.RemovalCause; +import com.google.common.cache.RemovalListener; +import com.google.common.cache.RemovalNotification; +import com.google.common.cache.Weigher; + +public class GuavaCacheTest { + + @Test + public void whenCacheMiss_thenAutoLoad() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().build(loader); + assertEquals(0, cache.size()); + assertEquals("HELLO", cache.getUnchecked("hello")); + assertEquals(1, cache.size()); + + } + + @Test + public void whenCacheReachMaxSize_thenEviction() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().maximumSize(3).build(loader); + assertEquals(0, cache.size()); + cache.getUnchecked("first"); + cache.getUnchecked("second"); + cache.getUnchecked("third"); + cache.getUnchecked("forth"); + assertEquals(3, cache.size()); + } + + @Test + public void whenCacheReachMaxWeight_thenEviction() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final Weigher weighByLength = new Weigher() { + @Override + public int weigh(final String key, final String value) { + return value.length(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().maximumWeight(16).weigher(weighByLength).build(loader); + assertEquals(0, cache.size()); + cache.getUnchecked("first"); + cache.getUnchecked("second"); + cache.getUnchecked("third"); + cache.getUnchecked("last"); + assertEquals(3, cache.size()); + } + + @Test + public void whenEntryIdle_thenEviction() throws InterruptedException { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().expireAfterAccess(2, TimeUnit.MILLISECONDS).build(loader); + cache.getUnchecked("hello"); + assertEquals(1, cache.size()); + cache.getUnchecked("hello"); + Thread.sleep(300); + cache.getUnchecked("test"); + assertEquals(1, cache.size()); + } + + @Test + public void whenEntryLiveTimeExpire_thenEviction() throws InterruptedException { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.MILLISECONDS).build(loader); + cache.getUnchecked("hello"); + assertEquals(1, cache.size()); + Thread.sleep(300); + cache.getUnchecked("test"); + assertEquals(1, cache.size()); + } + + @Test + public void whenWeekKeyHasNoRef_thenRemoveFromCache() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().weakKeys().build(loader); + assertEquals(0, cache.size()); + + } + + @Test + public void whenSoftValue_thenRemoveFromCache() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().softValues().build(loader); + assertEquals(0, cache.size()); + + } + + @Test + public void whenNullValue_thenOptional() { + + final CacheLoader> loader = new CacheLoader>() { + @Override + public Optional load(final String key) { + + return Optional.fromNullable(getSuffix(key)); + } + }; + + final LoadingCache> cache = CacheBuilder.newBuilder().build(loader); + + assertEquals("txt", cache.getUnchecked("text.txt").get()); + + assertFalse(cache.getUnchecked("hello").isPresent()); + + } + + @Test + public void whenLiveTimeEnd_thenRefresh() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().refreshAfterWrite(1, TimeUnit.MINUTES).build(loader); + assertEquals(0, cache.size()); + } + + + @Test + public void whenPreloadCache_thenUsePutAll() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().build(loader); + assertEquals(0, cache.size()); + final Map map = new HashMap(); + map.put("first", "FIRST"); + map.put("second", "SECOND"); + cache.putAll(map); + + assertEquals(2, cache.size()); + + } + + @Test + public void whenEntryRemovedFromCache_thenNotify() { + final CacheLoader loader = new CacheLoader() { + @Override + public String load(final String key) { + return key.toUpperCase(); + } + }; + + final RemovalListener listener = new RemovalListener() { + + @Override + public void onRemoval(final RemovalNotification n) { + if (n.wasEvicted()) { + final String cause = n.getCause().name(); + assertEquals(RemovalCause.SIZE.toString(), cause); + } + + } + }; + + final LoadingCache cache = CacheBuilder.newBuilder().maximumSize(3).removalListener(listener).build(loader); + cache.getUnchecked("first"); + cache.getUnchecked("second"); + cache.getUnchecked("third"); + cache.getUnchecked("last"); + + assertEquals(3, cache.size()); + } + + private String getSuffix(final String str) { + final int lastIndex = str.lastIndexOf('.'); + if (lastIndex == -1) + return null; + return str.substring(lastIndex + 1); + } + +} + + + From 5a97c3428a50e6fef19aeeca3158c0032c617f7a Mon Sep 17 00:00:00 2001 From: DOHA Date: Thu, 9 Oct 2014 11:46:58 +0200 Subject: [PATCH 6/9] Modify GuavaCacheTest --- .../org/baeldung/guava/GuavaCacheTest.java | 61 ++++++------------- 1 file changed, 18 insertions(+), 43 deletions(-) diff --git a/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java index df006498f4..aae2cf18f5 100644 --- a/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java +++ b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java @@ -2,6 +2,7 @@ package org.baeldung.guava; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; import java.util.HashMap; import java.util.Map; @@ -24,70 +25,66 @@ public class GuavaCacheTest { public void whenCacheMiss_thenAutoLoad() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().build(loader); assertEquals(0, cache.size()); assertEquals("HELLO", cache.getUnchecked("hello")); assertEquals(1, cache.size()); - } @Test public void whenCacheReachMaxSize_thenEviction() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().maximumSize(3).build(loader); - assertEquals(0, cache.size()); cache.getUnchecked("first"); cache.getUnchecked("second"); cache.getUnchecked("third"); cache.getUnchecked("forth"); assertEquals(3, cache.size()); + assertNull(cache.getIfPresent("first")); + assertEquals("FORTH", cache.getIfPresent("forth")); } @Test public void whenCacheReachMaxWeight_thenEviction() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final Weigher weighByLength = new Weigher() { @Override public int weigh(final String key, final String value) { return value.length(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().maximumWeight(16).weigher(weighByLength).build(loader); - assertEquals(0, cache.size()); cache.getUnchecked("first"); cache.getUnchecked("second"); cache.getUnchecked("third"); cache.getUnchecked("last"); assertEquals(3, cache.size()); + assertNull(cache.getIfPresent("first")); + assertEquals("LAST", cache.getIfPresent("last")); } @Test public void whenEntryIdle_thenEviction() throws InterruptedException { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().expireAfterAccess(2, TimeUnit.MILLISECONDS).build(loader); cache.getUnchecked("hello"); assertEquals(1, cache.size()); @@ -95,83 +92,70 @@ public class GuavaCacheTest { Thread.sleep(300); cache.getUnchecked("test"); assertEquals(1, cache.size()); + assertNull(cache.getIfPresent("hello")); } @Test public void whenEntryLiveTimeExpire_thenEviction() throws InterruptedException { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.MILLISECONDS).build(loader); cache.getUnchecked("hello"); assertEquals(1, cache.size()); Thread.sleep(300); cache.getUnchecked("test"); assertEquals(1, cache.size()); + assertNull(cache.getIfPresent("hello")); } @Test public void whenWeekKeyHasNoRef_thenRemoveFromCache() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().weakKeys().build(loader); - assertEquals(0, cache.size()); - } @Test public void whenSoftValue_thenRemoveFromCache() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().softValues().build(loader); - assertEquals(0, cache.size()); - } @Test public void whenNullValue_thenOptional() { - final CacheLoader> loader = new CacheLoader>() { @Override - public Optional load(final String key) { - + public final Optional load(final String key) { return Optional.fromNullable(getSuffix(key)); } }; - final LoadingCache> cache = CacheBuilder.newBuilder().build(loader); - assertEquals("txt", cache.getUnchecked("text.txt").get()); - assertFalse(cache.getUnchecked("hello").isPresent()); - } @Test public void whenLiveTimeEnd_thenRefresh() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().refreshAfterWrite(1, TimeUnit.MINUTES).build(loader); - assertEquals(0, cache.size()); } @@ -179,49 +163,40 @@ public class GuavaCacheTest { public void whenPreloadCache_thenUsePutAll() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final LoadingCache cache = CacheBuilder.newBuilder().build(loader); - assertEquals(0, cache.size()); final Map map = new HashMap(); map.put("first", "FIRST"); map.put("second", "SECOND"); cache.putAll(map); - assertEquals(2, cache.size()); - } @Test public void whenEntryRemovedFromCache_thenNotify() { final CacheLoader loader = new CacheLoader() { @Override - public String load(final String key) { + public final String load(final String key) { return key.toUpperCase(); } }; - final RemovalListener listener = new RemovalListener() { - @Override public void onRemoval(final RemovalNotification n) { if (n.wasEvicted()) { final String cause = n.getCause().name(); assertEquals(RemovalCause.SIZE.toString(), cause); } - } }; - final LoadingCache cache = CacheBuilder.newBuilder().maximumSize(3).removalListener(listener).build(loader); cache.getUnchecked("first"); cache.getUnchecked("second"); cache.getUnchecked("third"); cache.getUnchecked("last"); - assertEquals(3, cache.size()); } From 184feb8e2b9576888acaccf9976fa8d578b99346 Mon Sep 17 00:00:00 2001 From: eugenp Date: Thu, 9 Oct 2014 16:13:15 +0300 Subject: [PATCH 7/9] guava cleanup --- guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java index aae2cf18f5..87aba20ec3 100644 --- a/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java +++ b/guava/src/test/java/org/baeldung/guava/GuavaCacheTest.java @@ -158,7 +158,6 @@ public class GuavaCacheTest { final LoadingCache cache = CacheBuilder.newBuilder().refreshAfterWrite(1, TimeUnit.MINUTES).build(loader); } - @Test public void whenPreloadCache_thenUsePutAll() { final CacheLoader loader = new CacheLoader() { @@ -200,6 +199,8 @@ public class GuavaCacheTest { assertEquals(3, cache.size()); } + // UTIL + private String getSuffix(final String str) { final int lastIndex = str.lastIndexOf('.'); if (lastIndex == -1) From a04e03042b242677effcec333933ef4bde4f9ff2 Mon Sep 17 00:00:00 2001 From: DOHA Date: Sun, 12 Oct 2014 23:00:16 +0200 Subject: [PATCH 8/9] add class GuavaFilterCollectionsTest Test Example for article Guava - Predicates and Collections --- .../guava/GuavaFilterCollectionsTest.java | 157 ++++++++++++++++++ 1 file changed, 157 insertions(+) create mode 100644 guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java diff --git a/guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java b/guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java new file mode 100644 index 0000000000..060d61c887 --- /dev/null +++ b/guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java @@ -0,0 +1,157 @@ +package org.baeldung.guava; + +import static org.junit.Assert.assertEquals; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +import org.junit.Test; + +import com.google.common.base.Function; +import com.google.common.base.Functions; +import com.google.common.base.Predicate; +import com.google.common.base.Predicates; +import com.google.common.collect.Collections2; +import com.google.common.collect.FluentIterable; +import com.google.common.collect.ListMultimap; +import com.google.common.collect.Lists; +import com.google.common.collect.Multimaps; +import com.google.common.collect.Ordering; + +public class GuavaFilterCollectionsTest { + + @Test + public void whenFilterCollection_thenFiltered() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.filter(names, Predicates.containsPattern("a")); + + assertEquals(2, result.size()); + assertEquals("[Jane, Adam]", result.toString()); + } + + @Test + public void whenFilterCollectionWithCustomPredicate_thenFiltered() { + final Predicate predicate = new Predicate() { + @Override + public final boolean apply(final String input) { + return input.startsWith("A") || input.startsWith("J"); + } + }; + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.filter(names, predicate); + + assertEquals(3, result.size()); + assertEquals("[John, Jane, Adam]", result.toString()); + } + + @Test + public void whenFilterUsingMultiplePredicates_thenFiltered() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.filter(names, Predicates.or(Predicates.containsPattern("J"), Predicates.not(Predicates.containsPattern("a")))); + + assertEquals(3, result.size()); + assertEquals("[John, Jane, Tom]", result.toString()); + } + + @Test + public void whenTransformCollection_thenTransformed() { + final Function function = new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }; + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.transform(names, function); + + assertEquals(4, result.size()); + assertEquals("[4, 4, 4, 3]", result.toString()); + } + + @Test + public void whenTransformUsingComposedFunction_thenTransformed() { + final Function f1 = new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }; + + final Function f2 = new Function() { + @Override + public final Boolean apply(final Integer input) { + return input % 2 == 0; + } + }; + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.transform(names, Functions.compose(f2, f1)); + + assertEquals(4, result.size()); + assertEquals("[true, true, true, false]", result.toString()); + } + + @Test + public void whenFilterAndTransformCollection_thenCorrect() { + final Predicate predicate = new Predicate() { + @Override + public final boolean apply(final String input) { + return input.startsWith("A") || input.startsWith("T"); + } + }; + + final Function func = new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }; + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = FluentIterable.from(names).filter(predicate).transform(func).toList(); + + assertEquals(2, result.size()); + assertEquals("[4, 3]", result.toString()); + } + + @Test + public void whenSortCollection_thenSorted() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + Collections.sort(names, Ordering.natural()); + assertEquals("[Adam, Jane, John, Tom]", names.toString()); + } + + @Test + public void whenSortCollectionUsingCustomOrdering_thenSorted() { + final Ordering ordering = Ordering.natural().onResultOf(new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }); + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + Collections.sort(names, ordering); + assertEquals("[Tom, John, Jane, Adam]", names.toString()); + } + + @Test + public void whenGroupCollection_thenGrouped() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final ListMultimap groups = Multimaps.index(names, new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }); + + assertEquals(2, groups.keySet().size()); + assertEquals(3, groups.get(4).size()); + assertEquals("[Tom]", groups.get(3).toString()); + } + +} + From 1cd3d2e61784503345bf1d4fd632311bc7bf2be3 Mon Sep 17 00:00:00 2001 From: DOHA Date: Mon, 13 Oct 2014 21:27:39 +0200 Subject: [PATCH 9/9] Modify class GuavaFilterCollectionsTest Change class name, add new methods --- ... GuavaFilterTransformCollectionsTest.java} | 123 +++++++++++------- 1 file changed, 76 insertions(+), 47 deletions(-) rename guava/src/test/java/org/baeldung/guava/{GuavaFilterCollectionsTest.java => GuavaFilterTransformCollectionsTest.java} (61%) diff --git a/guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java b/guava/src/test/java/org/baeldung/guava/GuavaFilterTransformCollectionsTest.java similarity index 61% rename from guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java rename to guava/src/test/java/org/baeldung/guava/GuavaFilterTransformCollectionsTest.java index 060d61c887..d44edc962c 100644 --- a/guava/src/test/java/org/baeldung/guava/GuavaFilterCollectionsTest.java +++ b/guava/src/test/java/org/baeldung/guava/GuavaFilterTransformCollectionsTest.java @@ -1,9 +1,13 @@ package org.baeldung.guava; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.containsInAnyOrder; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; import java.util.Collection; -import java.util.Collections; import java.util.List; import org.junit.Test; @@ -14,20 +18,32 @@ import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.Collections2; import com.google.common.collect.FluentIterable; -import com.google.common.collect.ListMultimap; +import com.google.common.collect.Iterables; import com.google.common.collect.Lists; -import com.google.common.collect.Multimaps; -import com.google.common.collect.Ordering; -public class GuavaFilterCollectionsTest { + +public class GuavaFilterTransformCollectionsTest { @Test - public void whenFilterCollection_thenFiltered() { + public void whenFilterWithCollections2_thenFiltered() { final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); final Collection result = Collections2.filter(names, Predicates.containsPattern("a")); assertEquals(2, result.size()); - assertEquals("[Jane, Adam]", result.toString()); + assertThat(result, containsInAnyOrder("Jane", "Adam")); + + result.add("anna"); + assertEquals(5, names.size()); + result.remove("Adam"); + assertEquals(4, names.size()); + } + + @Test + public void whenFilterWithIterables_thenFiltered() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Iterable result = Iterables.filter(names, Predicates.containsPattern("a")); + + assertThat(result, containsInAnyOrder("Jane", "Adam")); } @Test @@ -43,7 +59,7 @@ public class GuavaFilterCollectionsTest { final Collection result = Collections2.filter(names, predicate); assertEquals(3, result.size()); - assertEquals("[John, Jane, Adam]", result.toString()); + assertThat(result, containsInAnyOrder("John", "Jane", "Adam")); } @Test @@ -52,11 +68,46 @@ public class GuavaFilterCollectionsTest { final Collection result = Collections2.filter(names, Predicates.or(Predicates.containsPattern("J"), Predicates.not(Predicates.containsPattern("a")))); assertEquals(3, result.size()); - assertEquals("[John, Jane, Tom]", result.toString()); + assertThat(result, containsInAnyOrder("John", "Jane", "Tom")); } @Test - public void whenTransformCollection_thenTransformed() { + public void whenRemoveNullFromCollection_thenRemoved() { + final List names = Lists.newArrayList("John", null, "Jane", null, "Adam", "Tom"); + final Collection result = Collections2.filter(names, Predicates.notNull()); + + assertEquals(4, result.size()); + assertThat(result, containsInAnyOrder("John", "Jane", "Adam", "Tom")); + } + + @Test + public void whenCheckAllElementsForCondition_thenChecked() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + + boolean result = Iterables.all(names, Predicates.containsPattern("n|m")); + assertTrue(result); + + result = Iterables.all(names, Predicates.containsPattern("a")); + assertFalse(result); + } + + @Test + public void whenTransformWithIterables_thenTransformed() { + final Function function = new Function() { + @Override + public final Integer apply(final String input) { + return input.length(); + } + }; + + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Iterable result = Iterables.transform(names, function); + + assertThat(result, contains(4, 4, 4, 3)); + } + + @Test + public void whenTransformWithCollections2_thenTransformed() { final Function function = new Function() { @Override public final Integer apply(final String input) { @@ -68,7 +119,10 @@ public class GuavaFilterCollectionsTest { final Collection result = Collections2.transform(names, function); assertEquals(4, result.size()); - assertEquals("[4, 4, 4, 3]", result.toString()); + assertThat(result, contains(4, 4, 4, 3)); + + result.remove(3); + assertEquals(3, names.size()); } @Test @@ -91,7 +145,16 @@ public class GuavaFilterCollectionsTest { final Collection result = Collections2.transform(names, Functions.compose(f2, f1)); assertEquals(4, result.size()); - assertEquals("[true, true, true, false]", result.toString()); + assertThat(result, contains(true, true, true, false)); + } + + @Test + public void whenCreateFunctionFromPredicate_thenCreated() { + final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); + final Collection result = Collections2.transform(names, Functions.forPredicate(Predicates.containsPattern("m"))); + + assertEquals(4, result.size()); + assertThat(result, contains(false, false, true, true)); } @Test @@ -114,44 +177,10 @@ public class GuavaFilterCollectionsTest { final Collection result = FluentIterable.from(names).filter(predicate).transform(func).toList(); assertEquals(2, result.size()); - assertEquals("[4, 3]", result.toString()); + assertThat(result, containsInAnyOrder(4, 3)); } - @Test - public void whenSortCollection_thenSorted() { - final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); - Collections.sort(names, Ordering.natural()); - assertEquals("[Adam, Jane, John, Tom]", names.toString()); - } - @Test - public void whenSortCollectionUsingCustomOrdering_thenSorted() { - final Ordering ordering = Ordering.natural().onResultOf(new Function() { - @Override - public final Integer apply(final String input) { - return input.length(); - } - }); - - final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); - Collections.sort(names, ordering); - assertEquals("[Tom, John, Jane, Adam]", names.toString()); - } - - @Test - public void whenGroupCollection_thenGrouped() { - final List names = Lists.newArrayList("John", "Jane", "Adam", "Tom"); - final ListMultimap groups = Multimaps.index(names, new Function() { - @Override - public final Integer apply(final String input) { - return input.length(); - } - }); - - assertEquals(2, groups.keySet().size()); - assertEquals(3, groups.get(4).size()); - assertEquals("[Tom]", groups.get(3).toString()); - } }