merge with base repo

2017-11-15 23:04:11 +02:00
parent 56c4397f9d d54917c7e9
commit 0568de3d94
1008 changed files with 9562 additions and 702 deletions
@@ -0,0 +1,39 @@
+package com.baeldung.breakcontinue;
+
+import static com.baeldung.breakcontinue.BreakContinue.labeledBreak;
+import static com.baeldung.breakcontinue.BreakContinue.labeledContinue;
+import static com.baeldung.breakcontinue.BreakContinue.unlabeledBreak;
+import static com.baeldung.breakcontinue.BreakContinue.unlabeledBreakNestedLoops;
+import static com.baeldung.breakcontinue.BreakContinue.unlabeledContinue;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BreakContinueTest {
+
+    @Test
+    public void whenUnlabeledBreak_ThenEqual() {
+        assertEquals(4, unlabeledBreak());
+    }
+
+    @Test
+    public void whenUnlabeledBreakNestedLoops_ThenEqual() {
+        assertEquals(2, unlabeledBreakNestedLoops());
+    }
+
+    @Test
+    public void whenLabeledBreak_ThenEqual() {
+        assertEquals(1, labeledBreak());
+    }
+
+    @Test
+    public void whenUnlabeledContinue_ThenEqual() {
+        assertEquals(5, unlabeledContinue());
+    }
+
+    @Test
+    public void whenLabeledContinue_ThenEqual() {
+        assertEquals(3, labeledContinue());
+    }
+
+}
@@ -0,0 +1,42 @@
+package com.baeldung.javac;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SampleJavacPluginIntegrationTest {
+
+    private static final String CLASS_TEMPLATE =
+            "package com.baeldung.javac;\n" +
+            "\n" +
+            "public class Test {\n" +
+            "    public static %1$s service(@Positive %1$s i) {\n" +
+            "        return i;\n" +
+            "    }\n" +
+            "}\n" +
+            "";
+
+    private TestCompiler compiler = new TestCompiler();
+    private TestRunner   runner   = new TestRunner();
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenInt_whenNegative_thenThrowsException() throws Throwable {
+        compileAndRun(double.class,-1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenInt_whenZero_thenThrowsException() throws Throwable {
+        compileAndRun(int.class,0);
+    }
+
+    @Test
+    public void givenInt_whenPositive_thenSuccess() throws Throwable {
+        assertEquals(1, compileAndRun(int.class, 1));
+    }
+
+    private Object compileAndRun(Class<?> argumentType, Object argument) throws Throwable {
+        String qualifiedClassName = "com.baeldung.javac.Test";
+        byte[] byteCode = compiler.compile(qualifiedClassName, String.format(CLASS_TEMPLATE, argumentType.getName()));
+        return runner.run(byteCode, qualifiedClassName, "service", new Class[] {argumentType}, argument);
+    }
+}
@@ -0,0 +1,26 @@
+package com.baeldung.javac;
+
+import javax.tools.SimpleJavaFileObject;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+
+/** Holds compiled byte code in a byte array */
+public class SimpleClassFile extends SimpleJavaFileObject {
+
+    private ByteArrayOutputStream out;
+
+    public SimpleClassFile(URI uri) {
+        super(uri, Kind.CLASS);
+    }
+
+    @Override
+    public OutputStream openOutputStream() throws IOException {
+        return out = new ByteArrayOutputStream();
+    }
+
+    public byte[] getCompiledBinaries() {
+        return out.toByteArray();
+    }
+}
@@ -0,0 +1,34 @@
+package com.baeldung.javac;
+
+import javax.tools.*;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Adapts {@link SimpleClassFile} to the {@link JavaCompiler} */
+public class SimpleFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {
+
+    private final List<SimpleClassFile> compiled = new ArrayList<>();
+
+    public SimpleFileManager(StandardJavaFileManager delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public JavaFileObject getJavaFileForOutput(Location location,
+                                               String className,
+                                               JavaFileObject.Kind kind,
+                                               FileObject sibling)
+    {
+        SimpleClassFile result = new SimpleClassFile(URI.create("string://" + className));
+        compiled.add(result);
+        return result;
+    }
+
+    /**
+     * @return  compiled binaries processed by the current class
+     */
+    public List<SimpleClassFile> getCompiled() {
+        return compiled;
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.javac;
+
+import javax.tools.SimpleJavaFileObject;
+import java.net.URI;
+
+/** Exposes given test source to the compiler. */
+public class SimpleSourceFile extends SimpleJavaFileObject {
+
+    private final String content;
+
+    public SimpleSourceFile(String qualifiedClassName, String testSource) {
+        super(URI.create(String.format("file://%s%s",
+                                       qualifiedClassName.replaceAll("\\.", "/"),
+                                       Kind.SOURCE.extension)),
+              Kind.SOURCE);
+        content = testSource;
+    }
+
+    @Override
+    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+        return content;
+    }
+}
@@ -0,0 +1,35 @@
+package com.baeldung.javac;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+
+public class TestCompiler {
+    public byte[] compile(String qualifiedClassName, String testSource) {
+        StringWriter output = new StringWriter();
+
+        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        SimpleFileManager fileManager = new SimpleFileManager(compiler.getStandardFileManager(
+                null,
+                null,
+                null
+        ));
+        List<SimpleSourceFile> compilationUnits = singletonList(new SimpleSourceFile(qualifiedClassName, testSource));
+        List<String> arguments = new ArrayList<>();
+        arguments.addAll(asList("-classpath", System.getProperty("java.class.path"),
+                                "-Xplugin:" + SampleJavacPlugin.NAME));
+        JavaCompiler.CompilationTask task = compiler.getTask(output,
+                                                             fileManager,
+                                                             null,
+                                                             arguments,
+                                                             null,
+                                                             compilationUnits);
+        task.call();
+        return fileManager.getCompiled().iterator().next().getCompiledBinaries();
+    }
+}
@@ -0,0 +1,41 @@
+package com.baeldung.javac;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class TestRunner {
+
+    public Object run(byte[] byteCode,
+                      String qualifiedClassName,
+                      String methodName,
+                      Class<?>[] argumentTypes,
+                      Object... args)
+            throws Throwable
+    {
+        ClassLoader classLoader = new ClassLoader() {
+            @Override
+            protected Class<?> findClass(String name) throws ClassNotFoundException {
+                return defineClass(name, byteCode, 0, byteCode.length);
+            }
+        };
+        Class<?> clazz;
+        try {
+            clazz = classLoader.loadClass(qualifiedClassName);
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("Can't load compiled test class", e);
+        }
+
+        Method method;
+        try {
+            method = clazz.getMethod(methodName, argumentTypes);
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Can't find the 'main()' method in the compiled test class", e);
+        }
+
+        try {
+            return method.invoke(null, args);
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+    }
+}
@@ -0,0 +1,137 @@
+package com.baeldung.stack;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Stack;
+
+import org.junit.Test;
+public class StackUnitTest {
+
+    @Test
+    public void whenStackIsCreated_thenItHasSize0() {
+        Stack intStack = new Stack();
+        assertEquals(0, intStack.size());
+    }
+
+    @Test
+    public void givenEmptyStack_whenElementIsPushed_thenStackSizeisIncreased() {
+        Stack intStack = new Stack();
+        intStack.push(1);
+        assertEquals(1, intStack.size());
+    }
+
+    @Test
+    public void givenEmptyStack_whenMultipleElementsArePushed_thenStackSizeisIncreased() {
+        Stack intStack = new Stack();
+        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+        boolean result = intStack.addAll(intList);
+        assertTrue(result);
+        assertEquals(7, intList.size());
+    }
+
+    @Test
+    public void whenElementIsPoppedFromStack_thenElementIsRemovedAndSizeChanges() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.pop();
+        assertTrue(intStack.isEmpty());
+    }
+
+    @Test
+    public void whenElementIsPeeked_thenElementIsNotRemovedAndSizeDoesNotChange() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.peek();
+        assertEquals(1, intStack.search(5));
+        assertEquals(1, intStack.size());
+    }
+
+    @Test
+    public void whenElementIsOnStack_thenSearchReturnsItsDistanceFromTheTop() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        assertEquals(1, intStack.search(5));
+    }
+
+    @Test
+    public void whenElementIsOnStack_thenIndexOfReturnsItsIndex() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        int indexOf = intStack.indexOf(5);
+        assertEquals(0, indexOf);
+    }
+
+    @Test
+    public void whenMultipleElementsAreOnStack_thenIndexOfReturnsLastElementIndex() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.push(5);
+        intStack.push(5);
+        int lastIndexOf = intStack.lastIndexOf(5);
+        assertEquals(2, lastIndexOf);
+    }
+
+    @Test
+    public void givenElementOnStack_whenRemoveElementIsInvoked_thenElementIsRemoved() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.push(5);
+        intStack.removeElement(5);
+        assertEquals(1, intStack.size());
+    }
+
+    @Test
+    public void givenElementOnStack_whenRemoveElementAtIsInvoked_thenElementIsRemoved() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.push(7);
+        intStack.removeElementAt(1);
+        assertEquals(-1, intStack.search(7));
+    }
+
+    @Test
+    public void givenElementsOnStack_whenRemoveAllElementsIsInvoked_thenAllElementsAreRemoved() {
+        Stack<Integer> intStack = new Stack();
+        intStack.push(5);
+        intStack.push(7);
+        intStack.removeAllElements();
+        assertTrue(intStack.isEmpty());
+    }
+
+    @Test
+    public void givenElementsOnStack_whenRemoveAllIsInvoked_thenAllElementsFromCollectionAreRemoved() {
+        Stack<Integer> intStack = new Stack();
+        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+        intStack.addAll(intList);
+        intStack.add(500);
+        intStack.removeAll(intList);
+        assertEquals(1, intStack.size());
+    }
+
+    @Test
+    public void givenElementsOnStack_whenRemoveIfIsInvoked_thenAllElementsSatysfyingConditionAreRemoved() {
+        Stack<Integer> intStack = new Stack();
+        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+        intStack.addAll(intList);
+        intStack.removeIf(element -> element < 6);
+        assertEquals(2, intStack.size());
+    }
+
+    @Test
+    public void whenAnotherStackCreatedWhileTraversingStack_thenStacksAreEqual() {
+        Stack<Integer> intStack = new Stack<>();
+        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
+        intStack.addAll(intList);
+        ListIterator<Integer> it = intStack.listIterator();
+        Stack<Integer> result = new Stack();
+        while(it.hasNext()) {
+            result.push(it.next());
+        }
+
+        assertThat(result, equalTo(intStack));
+    }
+}
@@ -0,0 +1,141 @@
+package com.baeldung.string.formatter;
+
+import java.util.Calendar;
+import java.util.Formatter;
+import java.util.GregorianCalendar;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+public class StringFormatterExampleTests {
+
+    @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: %1$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 \n"
+                + "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: %1$tm %1$te,%1$tY", c);
+        assertEquals("The date is: 12 10,2017", s);
+
+        s = String.format("The date is: %1$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 %1$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);
+    }
+
+}
@@ -0,0 +1,43 @@
+package com.baeldung.stringpool;
+
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class StringPoolUnitTest {
+
+    @Test
+    public void whenCreatingConstantStrings_thenTheirAddressesAreEqual() {
+        String constantString1 = "Baeldung";
+        String constantString2 = "Baeldung";
+
+        assertThat(constantString1).isSameAs(constantString2);
+    }
+
+    @Test
+    public void whenCreatingStringsWithTheNewOperator_thenTheirAddressesAreDifferent() {
+        String newString1 = new String("Baeldung");
+        String newString2 = new String("Baeldung");
+
+        assertThat(newString1).isNotSameAs(newString2);
+    }
+
+    @Test
+    public void whenComparingConstantAndNewStrings_thenTheirAddressesAreDifferent() {
+        String constantString = "Baeldung";
+        String newString = new String("Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+    }
+
+    @Test
+    public void whenInterningAStringWithIdenticalValueToAnother_thenTheirAddressesAreEqual() {
+        String constantString = "interned Baeldung";
+        String newString = new String("interned Baeldung");
+
+        assertThat(constantString).isNotSameAs(newString);
+
+        String internedString = newString.intern();
+
+        assertThat(constantString).isSameAs(internedString);
+    }
+}