Merge remote-tracking branch 'upstream/master' into BAEL-2440

JGit/src/main/java/com/baeldung/jgit/porcelain/Log.java

@@ -28,14 +28,14 @@ public class Log {
                 System.out.println("Had " + count + " commits overall on current branch");
 
                 logs = git.log()
-                        .add(repository.resolve("remotes/origin/testbranch"))
+                        .add(repository.resolve(git.getRepository().getFullBranch()))
                         .call();
                 count = 0;
                 for (RevCommit rev : logs) {
                     System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
                     count++;
                 }
-                System.out.println("Had " + count + " commits overall on test-branch");
+                System.out.println("Had " + count + " commits overall on "+git.getRepository().getFullBranch());
 
                 logs = git.log()
                         .all()

JGit/src/test/java/com/baeldung/jgit/JGitBugIntegrationTest.java

@@ -1,3 +1,5 @@
+package com.baeldung.jgit;
+
 import com.baeldung.jgit.helper.Helper;
 import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.ObjectReader;

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharacters.java

@@ -0,0 +1,54 @@
+package com.baeldung.algorithms.string;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class LongestSubstringNonRepeatingCharacters {
+
+    public static String getUniqueCharacterSubstringBruteForce(String input) {
+        String output = "";
+        for (int start = 0; start < input.length(); start++) {
+            Set<Character> visited = new HashSet<>();
+            int end = start;
+            for (; end < input.length(); end++) {
+                char currChar = input.charAt(end);
+                if (visited.contains(currChar)) {
+                    break;
+                } else {
+                    visited.add(currChar);
+                }
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end);
+            }
+        }
+        return output;
+    }
+
+    public static String getUniqueCharacterSubstring(String input) {
+        Map<Character, Integer> visited = new HashMap<>();
+        String output = "";
+        for (int start = 0, end = 0; end < input.length(); end++) {
+            char currChar = input.charAt(end);
+            if (visited.containsKey(currChar)) {
+                start = Math.max(visited.get(currChar) + 1, start);
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end + 1);
+            }
+            visited.put(currChar, end);
+        }
+        return output;
+    }
+
+    public static void main(String[] args) {
+        if(args.length > 0) {
+            System.out.println(getUniqueCharacterSubstring(args[0]));
+        } else {
+            System.err.println("This program expects command-line input. Please try again!");
+        }
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharactersUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.algorithms.string;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstring;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstringBruteForce;
+
+public class LongestSubstringNonRepeatingCharactersUnitTest {
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringBruteForceCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstringBruteForce(""));
+        assertEquals("A", getUniqueCharacterSubstringBruteForce("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstringBruteForce("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstringBruteForce("always be coding"));
+    }
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstring(""));
+        assertEquals("A", getUniqueCharacterSubstring("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstring("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstring("always be coding"));
+    }
+
+}

algorithms-miscellaneous-2/pom.xml

@@ -33,6 +33,11 @@
             <artifactId>jgrapht-core</artifactId>
             <version>${org.jgrapht.core.version}</version>
         </dependency>
+        <dependency>
+        	<groupId>org.jgrapht</groupId>
+        	<artifactId>jgrapht-ext</artifactId>
+        	<version>${org.jgrapht.ext.version}</version>
+        </dependency>
         <dependency>
             <groupId>pl.allegro.finance</groupId>
             <artifactId>tradukisto</artifactId>
@@ -83,6 +88,7 @@
         <commons-math3.version>3.6.1</commons-math3.version>
         <tradukisto.version>1.0.1</tradukisto.version>
         <org.jgrapht.core.version>1.0.1</org.jgrapht.core.version>
+        <org.jgrapht.ext.version>1.0.1</org.jgrapht.ext.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
     </properties>

algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/GraphImageGenerationUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertTrue;
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import org.jgrapht.ext.JGraphXAdapter;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+import org.junit.Before;
+import org.junit.Test;
+import com.mxgraph.layout.mxCircleLayout;
+import com.mxgraph.layout.mxIGraphLayout;
+import com.mxgraph.util.mxCellRenderer;
+
+public class GraphImageGenerationUnitTest {
+    static DefaultDirectedGraph<String, DefaultEdge> g;
+
+    @Before
+    public void createGraph() throws IOException {
+        File imgFile = new File("src/test/resources/graph.png");
+        imgFile.createNewFile();
+        g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        String x1 = "x1";
+        String x2 = "x2";
+        String x3 = "x3";
+        g.addVertex(x1);
+        g.addVertex(x2);
+        g.addVertex(x3);
+        g.addEdge(x1, x2);
+        g.addEdge(x2, x3);
+        g.addEdge(x3, x1);
+    }
+
+    @Test
+    public void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
+        JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(g);
+        mxIGraphLayout layout = new mxCircleLayout(graphAdapter);
+        layout.execute(graphAdapter.getDefaultParent());
+        File imgFile = new File("src/test/resources/graph.png");
+        BufferedImage image = mxCellRenderer.createBufferedImage(graphAdapter, null, 2, Color.WHITE, true, null);
+        ImageIO.write(image, "PNG", imgFile);
+        assertTrue(imgFile.exists());
+    }
+}

core-java-net/README.md

@@ -1,3 +0,0 @@
-=========
-
-## Core Java Net

core-java-networking/README.md

@@ -0,0 +1,7 @@
+=========
+
+## Core Java Networking
+
+### Relevant Articles
+
+- [Connecting Through Proxy Servers in Core Java](https://www.baeldung.com/java-connect-via-proxy-server)

core-java-networking/pom.xml

@@ -1,10 +1,10 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <artifactId>core-java-net</artifactId>
+    <artifactId>core-java-networking</artifactId>
     <version>0.1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
-    <name>core-java-net</name>
+    <name>core-java-networking</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -14,6 +14,6 @@
     </parent>
 
     <build>
-        <finalName>core-java-net</finalName>
+        <finalName>core-java-networking</finalName>
     </build>
 </project>

core-java/src/main/java/com/baeldung/basicsyntax/SimpleAddition.java

@@ -0,0 +1,11 @@
+package com.baeldung.basicsyntax;
+
+public class SimpleAddition {
+
+    public static void main(String[] args) {
+        int a = 10;
+        int b = 5;
+        double c = a + b;
+        System.out.println( a + " + " + b + " = " + c);
+    }
+}

core-java/src/test/java/com/baeldung/java/properties/PropertiesUnitTest.java

@@ -0,0 +1,171 @@
+package com.baeldung.java.properties;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.Properties;
+
+import org.junit.Test;
+
+public class PropertiesUnitTest {
+
+    @Test
+    public void givenPropertyValue_whenPropertiesFileLoaded_thenCorrect() throws IOException {
+     
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        String catalogConfigPath = rootPath + "catalog";
+        
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+         
+        Properties catalogProps = new Properties();
+        catalogProps.load(new FileInputStream(catalogConfigPath));
+        
+        String appVersion = appProps.getProperty("version");
+        assertEquals("1.0", appVersion);
+        
+        assertEquals("files", catalogProps.getProperty("c1"));
+    }
+    
+    @Test
+    public void givenPropertyValue_whenXMLPropertiesFileLoaded_thenCorrect() throws IOException {
+     
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String iconConfigPath = rootPath + "icons.xml";
+        Properties iconProps = new Properties();
+        iconProps.loadFromXML(new FileInputStream(iconConfigPath));
+        
+        assertEquals("icon1.jpg", iconProps.getProperty("fileIcon"));
+    }
+    
+    @Test
+    public void givenAbsentProperty_whenPropertiesFileLoaded_thenReturnsDefault() throws IOException {
+    
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+        
+        String appVersion = appProps.getProperty("version");
+        String appName = appProps.getProperty("name", "defaultName");
+        String appGroup = appProps.getProperty("group", "baeldung");
+        String appDownloadAddr = appProps.getProperty("downloadAddr");
+        
+        assertEquals("1.0", appVersion);
+        assertEquals("TestApp", appName);
+        assertEquals("baeldung", appGroup);
+        assertNull(appDownloadAddr);
+    }
+    
+    @Test(expected = Exception.class)
+    public void givenImproperObjectCasting_whenPropertiesFileLoaded_thenThrowsException() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+        
+        float appVerFloat = (float) appProps.get("version");
+    }
+    
+    @Test
+    public void givenPropertyValue_whenPropertiesSet_thenCorrect() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+        
+        appProps.setProperty("name", "NewAppName");
+        appProps.setProperty("downloadAddr", "www.baeldung.com/downloads");
+        
+        String newAppName = appProps.getProperty("name");
+        assertEquals("NewAppName", newAppName);
+        
+        String newAppDownloadAddr = appProps.getProperty("downloadAddr");
+        assertEquals("www.baeldung.com/downloads", newAppDownloadAddr);
+    }
+    
+    @Test
+    public void givenPropertyValueNull_whenPropertiesRemoved_thenCorrect() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+        
+        String versionBeforeRemoval = appProps.getProperty("version");
+        assertEquals("1.0", versionBeforeRemoval);
+
+        appProps.remove("version");    
+        String versionAfterRemoval = appProps.getProperty("version");
+        assertNull(versionAfterRemoval);
+    }
+    
+    @Test
+    public void whenPropertiesStoredInFile_thenCorrect() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appConfigPath));
+        
+        String newAppConfigPropertiesFile = rootPath + "newApp.properties";
+        appProps.store(new FileWriter(newAppConfigPropertiesFile), "store to properties file");
+        
+        String newAppConfigXmlFile = rootPath + "newApp.xml";
+        appProps.storeToXML(new FileOutputStream(newAppConfigXmlFile), "store to xml file");
+    }
+    
+    @Test
+    public void givenPropertyValueAbsent_LoadsValuesFromDefaultProperties() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        
+        String defaultConfigPath = rootPath + "default.properties";
+        Properties defaultProps = new Properties();
+        defaultProps.load(new FileInputStream(defaultConfigPath));
+         
+        String appConfigPath = rootPath + "app.properties";
+        Properties appProps = new Properties(defaultProps);
+        appProps.load(new FileInputStream(appConfigPath));
+         
+        String appName = appProps.getProperty("name");        
+        String appVersion = appProps.getProperty("version");
+        String defaultSite = appProps.getProperty("site");
+        
+        assertEquals("1.0", appVersion);
+        assertEquals("TestApp", appName);
+        assertEquals("www.google.com", defaultSite);
+    }
+
+    @Test
+    public void givenPropertiesSize_whenPropertyFileLoaded_thenCorrect() throws IOException {
+        
+        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
+        String appPropsPath = rootPath + "app.properties";
+        Properties appProps = new Properties();
+        appProps.load(new FileInputStream(appPropsPath));
+         
+        appProps.list(System.out); // list all key-value pairs
+        
+        Enumeration<Object> valueEnumeration = appProps.elements();
+        while (valueEnumeration.hasMoreElements()) {
+            System.out.println(valueEnumeration.nextElement());
+        }
+         
+        Enumeration<Object> keyEnumeration = appProps.keys();
+        while (keyEnumeration.hasMoreElements()) {
+            System.out.println(keyEnumeration.nextElement());
+        }
+         
+        int size = appProps.size();
+        assertEquals(3, size);
+    }
+}

core-java/src/test/resources/app.properties

@@ -0,0 +1,3 @@
+version=1.0
+name=TestApp
+date=2016-11-12

core-java/src/test/resources/catalog

@@ -0,0 +1,3 @@
+c1=files
+c2=images
+c3=videos

core-java/src/test/resources/default.properties

@@ -0,0 +1,4 @@
+site=www.google.com
+name=DefaultAppName
+topic=Properties
+category=core-java

core-java/src/test/resources/icons.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
+<properties>
+    <comment>xml example</comment>
+    <entry key="fileIcon">icon1.jpg</entry>
+    <entry key="imageIcon">icon2.jpg</entry>
+    <entry key="videoIcon">icon3.jpg</entry>
+</properties>

core-kotlin/src/main/kotlin/com/baeldung/functions/Inline.kt

@@ -0,0 +1,28 @@
+package com.baeldung.functions
+
+import kotlin.random.Random
+
+/**
+ * An extension function on all collections to apply a function to all collection
+ * elements.
+ */
+fun <T> Collection<T>.each(block: (T) -> Unit) {
+    for (e in this) block(e)
+}
+
+/**
+ * In order to see the the JVM bytecode:
+ *  1. Compile the Kotlin file using `kotlinc Inline.kt`
+ *  2. Take a peek at the bytecode using the `javap -c InlineKt`
+ */
+fun main() {
+    val numbers = listOf(1, 2, 3, 4, 5)
+    val random = random()
+
+    numbers.each { println(random * it) } // capturing the random variable
+}
+
+/**
+ * Generates a random number.
+ */
+private fun random(): Int = Random.nextInt()

events/README.md

@@ -1 +0,0 @@
-## Relevant articles: