Move articles out of java-strings part2

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/charsequence/CharSequenceVsStringUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.charsequence;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+public class CharSequenceVsStringUnitTest {
+
+    @Test
+    public void givenUsingString_whenInstantiatingString_thenWrong() {
+        CharSequence firstString = "bealdung";
+        String secondString = "baeldung";
+
+        assertNotEquals(firstString, secondString);
+    }
+
+    @Test
+    public void givenIdenticalCharSequences_whenCastToString_thenEqual() {
+        CharSequence charSequence1 = "baeldung_1";
+        CharSequence charSequence2 = "baeldung_2";
+
+        assertTrue(charSequence1.toString().compareTo(charSequence2.toString()) < 0);
+    }
+
+    @Test
+    public void givenString_whenAppended_thenUnmodified() {
+        String test = "a";
+        int firstAddressOfTest = System.identityHashCode(test);
+        test += "b";
+        int secondAddressOfTest = System.identityHashCode(test);
+
+        assertNotEquals(firstAddressOfTest, secondAddressOfTest);
+    }
+
+    @Test
+    public void givenStringBuilder_whenAppended_thenModified() {
+        StringBuilder test = new StringBuilder();
+        test.append("a");
+        int firstAddressOfTest = System.identityHashCode(test);
+        test.append("b");
+        int secondAddressOfTest = System.identityHashCode(test);
+
+        assertEquals(firstAddressOfTest, secondAddressOfTest);
+    }
+}

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/formatter/StringFormatterExampleUnitTest.java

@@ -0,0 +1,141 @@
+package com.baeldung.formatter;
+
+import org.junit.Test;
+
+import java.util.Calendar;
+import java.util.Formatter;
+import java.util.GregorianCalendar;
+
+import static org.junit.Assert.*;
+
+public class StringFormatterExampleUnitTest {
+
+    @Test
+    public void givenString_whenFormatSpecifierForCalendar_thenGotExpected() {
+        //Syntax of Format Specifiers for Date/Time Representation
+        Calendar c = new GregorianCalendar(2017, 11, 10);
+        String s = String.format("The date is: %tm %1$te,%1$tY", c);
+
+
+        assertEquals("The date is: 12 10,2017", s);
+    }
+
+    @Test
+    public void givenString_whenGeneralConversion_thenConvertedString() {
+        //General Conversions
+        String s = String.format("The correct answer is %s", false);
+        assertEquals("The correct answer is false", s);
+
+        s = String.format("The correct answer is %b", null);
+        assertEquals("The correct answer is false", s);
+
+        s = String.format("The correct answer is %B", true);
+        assertEquals("The correct answer is TRUE", s);
+    }
+    
+    @Test
+    public void givenString_whenCharConversion_thenConvertedString() {        
+        //Character Conversions
+        String s = String.format("The correct answer is %c", 'a');
+        assertEquals("The correct answer is a", s);
+
+        s = String.format("The correct answer is %c", null);
+        assertEquals("The correct answer is null", s);
+
+        s = String.format("The correct answer is %C", 'b');
+        assertEquals("The correct answer is B", s);
+        
+        s = String.format("The valid unicode character: %c", 0x0400);
+        assertTrue(Character.isValidCodePoint(0x0400));
+        assertEquals("The valid unicode character: Ѐ", s);
+    }
+    
+    @Test(expected = java.util.IllegalFormatCodePointException.class)
+    public void givenString_whenIllegalCodePointForConversion_thenError() {        
+        String s = String.format("The valid unicode character: %c", 0x11FFFF);
+        assertFalse(Character.isValidCodePoint(0x11FFFF));
+        assertEquals("The valid unicode character: Ā", s);
+    }
+    
+    @Test
+    public void givenString_whenNumericIntegralConversion_thenConvertedString() {
+        //Numeric Integral Conversions
+        String s = String.format("The number 25 in decimal = %d", 25);
+        assertEquals("The number 25 in decimal = 25", s);
+
+        s = String.format("The number 25 in octal = %o", 25);
+        assertEquals("The number 25 in octal = 31", s);
+
+        s = String.format("The number 25 in hexadecimal = %x", 25);
+        assertEquals("The number 25 in hexadecimal = 19", s);
+    }
+    
+    @Test
+    public void givenString_whenNumericFloatingConversion_thenConvertedString() {        
+        //Numeric Floating-point Conversions
+        String s = String.format("The computerized scientific format of 10000.00 "
+                + "= %e", 10000.00);
+        assertEquals("The computerized scientific format of 10000.00 = 1.000000e+04", s);
+
+        s = String.format("The decimal format of 10.019 = %f", 10.019);
+        assertEquals("The decimal format of 10.019 = 10.019000", s);
+    }
+    
+    @Test
+    public void givenString_whenLineSeparatorConversion_thenConvertedString() {        
+        //Line Separator Conversion
+        String s = String.format("First Line %nSecond Line");
+        assertEquals("First Line " + System.getProperty("line.separator")
+                + "Second Line", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyFlag_thenGotFormattedString() {
+        //Without left-justified flag
+        String s = String.format("Without left justified flag: %5d", 25);
+        assertEquals("Without left justified flag:    25", s);
+
+        //Using left-justified flag
+        s = String.format("With left justified flag: %-5d", 25);
+        assertEquals("With left justified flag: 25   ", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyPrecision_thenGotExpected() {
+
+        //Precision
+        String s = String.format("Output of 25.09878 with Precision 2: %.2f", 25.09878);
+        assertEquals("Output of 25.09878 with Precision 2: 25.10", s);
+
+        s = String.format("Output of general conversion type with Precision 2: %.2b", true);
+        assertEquals("Output of general conversion type with Precision 2: tr", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyArgumentIndex_thenGotExpected() {
+        Calendar c = new GregorianCalendar(2017, 11, 10);
+        //Argument_Index
+        String s = String.format("The date is: %tm %1$te,%1$tY", c);
+        assertEquals("The date is: 12 10,2017", s);
+       
+        s = String.format("The date is: %tm %<te,%<tY", c);
+        assertEquals("The date is: 12 10,2017", s);
+    }
+
+    @Test
+    public void givenAppendable_whenCreateFormatter_thenFormatterWorksOnAppendable() {
+        //Using String Formatter with Appendable
+        StringBuilder sb = new StringBuilder();
+        Formatter formatter = new Formatter(sb);
+        formatter.format("I am writting to a %s Instance.", sb.getClass());
+        assertEquals("I am writting to a class java.lang.StringBuilder Instance.", sb.toString());
+    }
+    
+    @Test
+    public void givenString_whenNoArguments_thenExpected() {
+        //Using String Formatter without arguments
+        String s = String.format("John scored 90%% in Fall semester");
+        assertEquals("John scored 90% in Fall semester", s);
+    }
+
+}

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/password/StringPasswordUnitTest.java

@@ -0,0 +1,64 @@
+package com.baeldung.password;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Examples of passwords conforming to various specifications, using different libraries.
+ * 
+ */
+public class StringPasswordUnitTest {
+
+    RandomPasswordGenerator passGen = new RandomPasswordGenerator();
+
+    @Test
+    public void whenPasswordGeneratedUsingPassay_thenSuccessful() {
+        String password = passGen.generatePassayPassword();
+        int specialCharCount = 0;
+        for (char c : password.toCharArray()) {
+            if (c >= 33 || c <= 47) {
+                specialCharCount++;
+            }
+        }
+        assertTrue("Password validation failed in Passay", specialCharCount >= 2);
+    }
+
+    @Test
+    public void whenPasswordGeneratedUsingCommonsText_thenSuccessful() {
+        RandomPasswordGenerator passGen = new RandomPasswordGenerator();
+        String password = passGen.generateCommonTextPassword();
+        int lowerCaseCount = 0;
+        for (char c : password.toCharArray()) {
+            if (c >= 97 || c <= 122) {
+                lowerCaseCount++;
+            }
+        }
+        assertTrue("Password validation failed in commons-text ", lowerCaseCount >= 2);
+    }
+
+    @Test
+    public void whenPasswordGeneratedUsingCommonsLang3_thenSuccessful() {
+        String password = passGen.generateCommonsLang3Password();
+        int numCount = 0;
+        for (char c : password.toCharArray()) {
+            if (c >= 48 || c <= 57) {
+                numCount++;
+            }
+        }
+        assertTrue("Password validation failed in commons-lang3", numCount >= 2);
+    }
+
+    @Test
+    public void whenPasswordGeneratedUsingSecureRandom_thenSuccessful() {
+        String password = passGen.generateSecureRandomPassword();
+        int specialCharCount = 0;
+        for (char c : password.toCharArray()) {
+            if (c >= 33 || c <= 47) {
+                specialCharCount++;
+            }
+        }
+        assertTrue("Password validation failed in Secure Random", specialCharCount >= 2);
+    }
+
+}

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/streamtokenizer/StreamTokenizerDemoUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.streamtokenizer;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class StreamTokenizerDemoUnitTest {
+
+    @Test
+    public void whenStreamTokenizerWithDefaultConfigurationIsCalled_ThenCorrectTokensAreReturned() throws IOException {
+        Reader reader = StreamTokenizerDemo.createReaderFromFile();
+        List<Object> expectedTokens = Arrays.asList(3.0, "quick", "brown", "foxes", "jump", "over", "the", "lazy", "dog", '!', '#', "test1");
+
+        List<Object> actualTokens = StreamTokenizerDemo.streamTokenizerWithDefaultConfiguration(reader);
+
+        assertArrayEquals(expectedTokens.toArray(), actualTokens.toArray());
+    }
+
+    @Test
+    public void whenStreamTokenizerWithCustomConfigurationIsCalled_ThenCorrectTokensAreReturned() throws IOException {
+        Reader reader = StreamTokenizerDemo.createReaderFromFile();
+        List<Object> expectedTokens = Arrays.asList(3.0, "quick", "brown", "foxes", "jump", "over", "the", "\"lazy\"", "dog!", '\n', '\n', '/', '/', "test2");
+
+        List<Object> actualTokens = StreamTokenizerDemo.streamTokenizerWithCustomConfiguration(reader);
+
+        assertArrayEquals(expectedTokens.toArray(), actualTokens.toArray());
+    }
+
+}

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/stringjoiner/StringJoinerUnitTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.stringjoiner;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringJoinerUnitTest {
+    private final String DELIMITER_COMMA = ",";
+    private final String DELIMITER_HYPHEN = "-";
+    private final String PREFIX = "[";
+    private final String SUFFIX = "]";
+    private final String EMPTY_JOINER = "empty";
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        assertEquals(0, commaSeparatedJoiner.toString().length());
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithoutEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), PREFIX + SUFFIX);
+    }
+
+    @Test
+    public void whenJoinerWithoutPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedJoiner = new StringJoiner(DELIMITER_COMMA);
+        commaSeparatedJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenJoinerWithPrefixSuffixWithEmptyValue_thenReturnDefault() {
+        StringJoiner commaSeparatedPrefixSuffixJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        commaSeparatedPrefixSuffixJoiner.setEmptyValue(EMPTY_JOINER);
+
+        assertEquals(commaSeparatedPrefixSuffixJoiner.toString(), EMPTY_JOINER);
+    }
+
+    @Test
+    public void whenAddElements_thenJoinElements() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenAddListElements_thenJoinListElements() {
+        List<String> rgbList = new ArrayList<String>();
+        rgbList.add("Red");
+        rgbList.add("Green");
+        rgbList.add("Blue");
+
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+
+        for (String color : rgbList) {
+            rgbJoiner.add(color);
+        }
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue]");
+    }
+
+    @Test
+    public void whenMergeJoiners_thenReturnMerged() {
+        StringJoiner rgbJoiner = new StringJoiner(DELIMITER_COMMA, PREFIX, SUFFIX);
+        StringJoiner cmybJoiner = new StringJoiner(DELIMITER_HYPHEN, PREFIX, SUFFIX);
+
+        rgbJoiner.add("Red")
+          .add("Green")
+          .add("Blue");
+        cmybJoiner.add("Cyan")
+          .add("Magenta")
+          .add("Yellow")
+          .add("Black");
+
+        rgbJoiner.merge(cmybJoiner);
+
+        assertEquals(rgbJoiner.toString(), "[Red,Green,Blue,Cyan-Magenta-Yellow-Black]");
+    }
+
+    @Test
+    public void whenUsedWithinCollectors_thenJoin() {
+        List<String> rgbList = Arrays.asList("Red", "Green", "Blue");
+        String commaSeparatedRGB = rgbList.stream()
+          .map(color -> color.toString())
+          .collect(Collectors.joining(","));
+
+        assertEquals(commaSeparatedRGB, "Red,Green,Blue");
+    }
+}

core-java-modules/core-java-string-apis/src/test/java/com/baeldung/stringtokenizer/TokenizerUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.stringtokenizer;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class TokenizerUnitTest {
+
+	private final MyTokenizer myTokenizer = new MyTokenizer();
+	private final List<String> expectedTokensForString = Arrays.asList("Welcome", "to", "baeldung.com");
+	private final List<String> expectedTokensForFile = Arrays.asList("1", "IND", "India", "2", "MY", "Malaysia", "3", "AU", "Australia");
+
+	@Test
+	public void givenString_thenGetListOfString() {
+		String str = "Welcome,to,baeldung.com";
+		List<String> actualTokens = myTokenizer.getTokens(str);
+		assertEquals(expectedTokensForString, actualTokens);
+	}
+
+	@Test
+	public void givenFile_thenGetListOfString() {
+		List<String> actualTokens = myTokenizer.getTokensFromFile("data.csv", "|");
+		assertEquals(expectedTokensForFile, actualTokens);
+	}
+
+}

core-java-modules/core-java-string-apis/src/test/resources/data.csv

@@ -0,0 +1,3 @@
+1|IND|India
+2|MY|Malaysia
+3|AU|Australia

core-java-modules/core-java-string-apis/src/test/resources/stream-tokenizer-example.txt

@@ -0,0 +1,3 @@
+3 quick brown foxes jump over the "lazy" dog!
+#test1
+//test2