Merge branch 'master' into sla-pr/1108-junit

2017-02-13 01:21:45 +01:00
parent 23696a24bd 424f55ac48
commit 04a87a9df5
268 changed files with 4783 additions and 1020 deletions
@@ -57,3 +57,4 @@
 - [Guide to java.util.concurrent.Future](http://www.baeldung.com/java-future)
 - [Guide to java.util.concurrent.BlockingQueue](http://www.baeldung.com/java-blocking-queue)
 - [Guide to CountDownLatch in Java](http://www.baeldung.com/java-countdown-latch)
+- [How to Design a Genetic Algorithm in Java](http://www.baeldung.com/java-genetic-algorithm)
@@ -1,5 +1,5 @@
 <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">
+         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>
    <groupId>com.baeldung</groupId>
    <artifactId>core-java</artifactId>
@@ -10,6 +10,44 @@

    <dependencies>

+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j</artifactId>
+            <version>3.1.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j.driver</groupId>
+            <artifactId>neo4j-java-driver</artifactId>
+            <version>1.1.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-jdbc-driver</artifactId>
+            <version>3.0.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-core</artifactId>
+            <version>2.1.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-ogm-embedded-driver</artifactId>
+            <version>2.1.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.inject</groupId>
+            <artifactId>guice</artifactId>
+            <version>4.1.0</version>
+            <classifier>no_aop</classifier>
+            <scope>test</scope>
+        </dependency>
+
        <!-- utils -->
        <dependency>
            <groupId>net.sourceforge.collections</groupId>
@@ -63,7 +101,6 @@
            <artifactId>grep4j</artifactId>
            <version>${grep4j.version}</version>
        </dependency>
-        
        <!-- web -->

        <!-- marshalling -->
@@ -154,6 +191,12 @@
            <version>${mockito.version}</version>
            <scope>test</scope>
        </dependency>
+        <dependency>
+            <groupId>com.jayway.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${avaitility.version}</version>
+            <scope>test</scope>
+        </dependency>

        <dependency>
            <groupId>commons-codec</groupId>
@@ -263,7 +306,8 @@
                        <configuration>
                            <shadedArtifactAttached>true</shadedArtifactAttached>
                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                <transformer
+                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
                                </transformer>
                            </transformers>
@@ -371,6 +415,7 @@
        <mockito.version>1.10.19</mockito.version>
        <testng.version>6.10</testng.version>
        <assertj.version>3.6.1</assertj.version>
+        <avaitility.version>1.7.0</avaitility.version>

        <!-- maven plugins -->
        <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
@@ -24,7 +24,8 @@ public class RunAlgorithm {
 			SlopeOne.slopeOne(3);
 			break;
 		case 3:
-			SimpleGeneticAlgorithm.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111");
+			SimpleGeneticAlgorithm ga = new SimpleGeneticAlgorithm();
+			ga.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111");
 			break;
 		default:
 			System.out.println("Unknown option");
@@ -5,40 +5,40 @@ import lombok.Data;
@Data
 public class Individual {

-	protected int defaultGeneLength = 64;
-	private byte[] genes = new byte[defaultGeneLength];
-	private int fitness = 0;
+    protected int defaultGeneLength = 64;
+    private byte[] genes = new byte[defaultGeneLength];
+    private int fitness = 0;

-	public Individual() {
-		for (int i = 0; i < genes.length; i++) {
-			byte gene = (byte) Math.round(Math.random());
-			genes[i] = gene;
-		}
-	}
+    public Individual() {
+        for (int i = 0; i < genes.length; i++) {
+            byte gene = (byte) Math.round(Math.random());
+            genes[i] = gene;
+        }
+    }

-	protected byte getSingleGene(int index) {
-		return genes[index];
-	}
+    protected byte getSingleGene(int index) {
+        return genes[index];
+    }

-	protected void setSingleGene(int index, byte value) {
-		genes[index] = value;
-		fitness = 0;
-	}
+    protected void setSingleGene(int index, byte value) {
+        genes[index] = value;
+        fitness = 0;
+    }

-	public int getFitness() {
-		if (fitness == 0) {
-			fitness = SimpleGeneticAlgorithm.getFitness(this);
-		}
-		return fitness;
-	}
+    public int getFitness() {
+        if (fitness == 0) {
+            fitness = SimpleGeneticAlgorithm.getFitness(this);
+        }
+        return fitness;
+    }

-	@Override
-	public String toString() {
-		String geneString = "";
-		for (int i = 0; i < genes.length; i++) {
-			geneString += getSingleGene(i);
-		}
-		return geneString;
-	}
+    @Override
+    public String toString() {
+        String geneString = "";
+        for (int i = 0; i < genes.length; i++) {
+            geneString += getSingleGene(i);
+        }
+        return geneString;
+    }

 }
@@ -8,33 +8,33 @@ import lombok.Data;
@Data
 public class Population {

-	private List<Individual> individuals;
+    private List<Individual> individuals;

-	public Population(int size, boolean createNew) {
-		individuals = new ArrayList<>();
-		if (createNew) {
-			createNewPopulation(size);
-		}
-	}
+    public Population(int size, boolean createNew) {
+        individuals = new ArrayList<>();
+        if (createNew) {
+            createNewPopulation(size);
+        }
+    }

-	protected Individual getIndividual(int index) {
-		return individuals.get(index);
-	}
+    protected Individual getIndividual(int index) {
+        return individuals.get(index);
+    }

-	protected Individual getFittest() {
-		Individual fittest = individuals.get(0);
-		for (int i = 0; i < individuals.size(); i++) {
-			if (fittest.getFitness() <= getIndividual(i).getFitness()) {
-				fittest = getIndividual(i);
-			}
-		}
-		return fittest;
-	}
+    protected Individual getFittest() {
+        Individual fittest = individuals.get(0);
+        for (int i = 0; i < individuals.size(); i++) {
+            if (fittest.getFitness() <= getIndividual(i).getFitness()) {
+                fittest = getIndividual(i);
+            }
+        }
+        return fittest;
+    }

-	private void createNewPopulation(int size) {
-		for (int i = 0; i < size; i++) {
-			Individual newIndividual = new Individual();
-			individuals.add(i, newIndividual);
-		}
-	}
+    private void createNewPopulation(int size) {
+        for (int i = 0; i < size; i++) {
+            Individual newIndividual = new Individual();
+            individuals.add(i, newIndividual);
+        }
+    }
 }
@@ -5,115 +5,113 @@ import lombok.Data;
@Data
 public class SimpleGeneticAlgorithm {

-	private static final double uniformRate = 0.5;
-	private static final double mutationRate = 0.025;
-	private static final int tournamentSize = 5;
-	private static final boolean elitism = true;
-	private static byte[] solution = new byte[64];
+    private static final double uniformRate = 0.5;
+    private static final double mutationRate = 0.025;
+    private static final int tournamentSize = 5;
+    private static final boolean elitism = true;
+    private static byte[] solution = new byte[64];

-	public static boolean runAlgorithm(int populationSize, String solution) {
-		if (solution.length() != SimpleGeneticAlgorithm.solution.length) {
-			throw new RuntimeException(
-					"The solution needs to have " + SimpleGeneticAlgorithm.solution.length + " bytes");
-		}
-		SimpleGeneticAlgorithm.setSolution(solution);
-		Population myPop = new Population(populationSize, true);
+    public boolean runAlgorithm(int populationSize, String solution) {
+        if (solution.length() != SimpleGeneticAlgorithm.solution.length) {
+            throw new RuntimeException("The solution needs to have " + SimpleGeneticAlgorithm.solution.length + " bytes");
+        }
+        setSolution(solution);
+        Population myPop = new Population(populationSize, true);

-		int generationCount = 1;
-		while (myPop.getFittest().getFitness() < SimpleGeneticAlgorithm.getMaxFitness()) {
-			System.out.println(
-					"Generation: " + generationCount + " Correct genes found: " + myPop.getFittest().getFitness());
-			myPop = SimpleGeneticAlgorithm.evolvePopulation(myPop);
-			generationCount++;
-		}
-		System.out.println("Solution found!");
-		System.out.println("Generation: " + generationCount);
-		System.out.println("Genes: ");
-		System.out.println(myPop.getFittest());
-		return true;
-	}
+        int generationCount = 1;
+        while (myPop.getFittest().getFitness() < getMaxFitness()) {
+            System.out.println("Generation: " + generationCount + " Correct genes found: " + myPop.getFittest().getFitness());
+            myPop = evolvePopulation(myPop);
+            generationCount++;
+        }
+        System.out.println("Solution found!");
+        System.out.println("Generation: " + generationCount);
+        System.out.println("Genes: ");
+        System.out.println(myPop.getFittest());
+        return true;
+    }

-	public static Population evolvePopulation(Population pop) {
-		int elitismOffset;
-		Population newPopulation = new Population(pop.getIndividuals().size(), false);
+    public Population evolvePopulation(Population pop) {
+        int elitismOffset;
+        Population newPopulation = new Population(pop.getIndividuals().size(), false);

-		if (elitism) {
-			newPopulation.getIndividuals().add(0, pop.getFittest());
-			elitismOffset = 1;
-		} else {
-			elitismOffset = 0;
-		}
+        if (elitism) {
+            newPopulation.getIndividuals().add(0, pop.getFittest());
+            elitismOffset = 1;
+        } else {
+            elitismOffset = 0;
+        }

-		for (int i = elitismOffset; i < pop.getIndividuals().size(); i++) {
-			Individual indiv1 = tournamentSelection(pop);
-			Individual indiv2 = tournamentSelection(pop);
-			Individual newIndiv = crossover(indiv1, indiv2);
-			newPopulation.getIndividuals().add(i, newIndiv);
-		}
+        for (int i = elitismOffset; i < pop.getIndividuals().size(); i++) {
+            Individual indiv1 = tournamentSelection(pop);
+            Individual indiv2 = tournamentSelection(pop);
+            Individual newIndiv = crossover(indiv1, indiv2);
+            newPopulation.getIndividuals().add(i, newIndiv);
+        }

-		for (int i = elitismOffset; i < newPopulation.getIndividuals().size(); i++) {
-			mutate(newPopulation.getIndividual(i));
-		}
+        for (int i = elitismOffset; i < newPopulation.getIndividuals().size(); i++) {
+            mutate(newPopulation.getIndividual(i));
+        }

-		return newPopulation;
-	}
+        return newPopulation;
+    }

-	private static Individual crossover(Individual indiv1, Individual indiv2) {
-		Individual newSol = new Individual();
-		for (int i = 0; i < newSol.getDefaultGeneLength(); i++) {
-			if (Math.random() <= uniformRate) {
-				newSol.setSingleGene(i, indiv1.getSingleGene(i));
-			} else {
-				newSol.setSingleGene(i, indiv2.getSingleGene(i));
-			}
-		}
-		return newSol;
-	}
+    private Individual crossover(Individual indiv1, Individual indiv2) {
+        Individual newSol = new Individual();
+        for (int i = 0; i < newSol.getDefaultGeneLength(); i++) {
+            if (Math.random() <= uniformRate) {
+                newSol.setSingleGene(i, indiv1.getSingleGene(i));
+            } else {
+                newSol.setSingleGene(i, indiv2.getSingleGene(i));
+            }
+        }
+        return newSol;
+    }

-	private static void mutate(Individual indiv) {
-		for (int i = 0; i < indiv.getDefaultGeneLength(); i++) {
-			if (Math.random() <= mutationRate) {
-				byte gene = (byte) Math.round(Math.random());
-				indiv.setSingleGene(i, gene);
-			}
-		}
-	}
+    private void mutate(Individual indiv) {
+        for (int i = 0; i < indiv.getDefaultGeneLength(); i++) {
+            if (Math.random() <= mutationRate) {
+                byte gene = (byte) Math.round(Math.random());
+                indiv.setSingleGene(i, gene);
+            }
+        }
+    }

-	private static Individual tournamentSelection(Population pop) {
-		Population tournament = new Population(tournamentSize, false);
-		for (int i = 0; i < tournamentSize; i++) {
-			int randomId = (int) (Math.random() * pop.getIndividuals().size());
-			tournament.getIndividuals().add(i, pop.getIndividual(randomId));
-		}
-		Individual fittest = tournament.getFittest();
-		return fittest;
-	}
+    private Individual tournamentSelection(Population pop) {
+        Population tournament = new Population(tournamentSize, false);
+        for (int i = 0; i < tournamentSize; i++) {
+            int randomId = (int) (Math.random() * pop.getIndividuals().size());
+            tournament.getIndividuals().add(i, pop.getIndividual(randomId));
+        }
+        Individual fittest = tournament.getFittest();
+        return fittest;
+    }

-	protected static int getFitness(Individual individual) {
-		int fitness = 0;
-		for (int i = 0; i < individual.getDefaultGeneLength() && i < solution.length; i++) {
-			if (individual.getSingleGene(i) == solution[i]) {
-				fitness++;
-			}
-		}
-		return fitness;
-	}
+    protected static int getFitness(Individual individual) {
+        int fitness = 0;
+        for (int i = 0; i < individual.getDefaultGeneLength() && i < solution.length; i++) {
+            if (individual.getSingleGene(i) == solution[i]) {
+                fitness++;
+            }
+        }
+        return fitness;
+    }

-	protected static int getMaxFitness() {
-		int maxFitness = solution.length;
-		return maxFitness;
-	}
+    protected int getMaxFitness() {
+        int maxFitness = solution.length;
+        return maxFitness;
+    }

-	protected static void setSolution(String newSolution) {
-		solution = new byte[newSolution.length()];
-		for (int i = 0; i < newSolution.length(); i++) {
-			String character = newSolution.substring(i, i + 1);
-			if (character.contains("0") || character.contains("1")) {
-				solution[i] = Byte.parseByte(character);
-			} else {
-				solution[i] = 0;
-			}
-		}
-	}
+    protected void setSolution(String newSolution) {
+        solution = new byte[newSolution.length()];
+        for (int i = 0; i < newSolution.length(); i++) {
+            String character = newSolution.substring(i, i + 1);
+            if (character.contains("0") || character.contains("1")) {
+                solution[i] = Byte.parseByte(character);
+            } else {
+                solution[i] = 0;
+            }
+        }
+    }

 }
@@ -15,6 +15,6 @@ public class SquareCalculator {
        return executor.submit(() -> {
            Thread.sleep(1000);
            return input * input;
-        });        
+        });
    }
 }
@@ -0,0 +1,50 @@
+package com.baeldung.graph;
+
+import org.neo4j.ogm.annotation.GraphId;
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+/**
+ * @author Danil Kornishev ([email protected])
+ */
+@NodeEntity
+public class Car {
+    @GraphId
+    private Long id;
+
+    private String make;
+
+    @Relationship(direction = "INCOMING")
+    private Company company;
+
+    public Car(String make, String model) {
+        this.make = make;
+        this.model = model;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getMake() {
+        return make;
+    }
+
+    public void setMake(String make) {
+        this.make = make;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public void setModel(String model) {
+        this.model = model;
+    }
+
+    private String model;
+}
@@ -0,0 +1,45 @@
+package com.baeldung.graph;
+
+import org.neo4j.ogm.annotation.NodeEntity;
+import org.neo4j.ogm.annotation.Relationship;
+
+/**
+ * @author Danil Kornishev ([email protected])
+ */
+@NodeEntity
+public class Company {
+    private Long id;
+
+    private String name;
+
+    @Relationship(type="owns")
+    private Car car;
+
+    public Company(String name) {
+        this.name = name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Car getCar() {
+        return car;
+    }
+
+    public void setCar(Car car) {
+        this.car = car;
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.java_8_features.groupingby;
+
+public class BlogPost {
+    private String title;
+    private String author;
+    private BlogPostType type;
+    private int likes;
+
+    public BlogPost(String title, String author, BlogPostType type, int likes) {
+        this.title = title;
+        this.author = author;
+        this.type = type;
+        this.likes = likes;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public BlogPostType getType() {
+        return type;
+    }
+
+    public int getLikes() {
+        return likes;
+    }
+
+    @Override
+    public String toString() {
+        return "BlogPost{" + "title='" + title + '\'' + ", type=" + type + ", likes=" + likes + '}';
+    }
+}
@@ -0,0 +1,5 @@
+package com.baeldung.java_8_features.groupingby;
+
+public enum BlogPostType {
+    NEWS, REVIEW, GUIDE
+}
@@ -0,0 +1,11 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+
+public class ChristmasDiscounter implements Discounter {
+
+    @Override
+    public BigDecimal apply(BigDecimal amount) {
+        return amount.multiply(BigDecimal.valueOf(0.9));
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+import java.util.function.UnaryOperator;
+
+public interface Discounter extends UnaryOperator<BigDecimal> {
+
+    default Discounter combine(Discounter after) {
+        return value -> after.apply(this.apply(value));
+    }
+
+    static Discounter christmas() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.9));
+    }
+
+    static Discounter newYear() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.8));
+    }
+
+    static Discounter easter() {
+        return (amount) -> amount.multiply(BigDecimal.valueOf(0.5));
+    }
+}
@@ -0,0 +1,11 @@
+package com.baeldung.strategy;
+
+import java.math.BigDecimal;
+
+public class EasterDiscounter implements Discounter {
+
+    @Override
+    public BigDecimal apply(BigDecimal amount) {
+        return amount.multiply(BigDecimal.valueOf(0.5));
+    }
+}
@@ -0,0 +1,27 @@
+package com.baeldung.stream;
+
+
+import java.util.stream.Stream;
+
+public class InfiniteStreams {
+    public static void main(String[] args) {
+        doWhileOldWay();
+
+        doWhileStreamWay();
+
+    }
+
+    private static void doWhileOldWay() {
+
+        int i = 0;
+        while (i < 10) {
+            System.out.println(i);
+            i++;
+        }
+    }
+
+    private static void doWhileStreamWay() {
+        Stream<Integer> integers = Stream.iterate(0, i -> i + 1);
+        integers.limit(10).forEach(System.out::println);
+    }
+}
@@ -0,0 +1,36 @@
+package com.baeldung.string;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class JoinerSplitter {
+
+	public static String join ( String[] arrayOfString ) {
+		return Arrays.asList(arrayOfString)
+				.stream()
+				.map(x -> x)
+				.collect(Collectors.joining(","));
+	}
+	
+	public static String joinWithPrefixPostFix ( String[] arrayOfString ) {
+		return Arrays.asList(arrayOfString)
+				.stream()
+				.map(x -> x)
+				.collect(Collectors.joining(",","[","]"));
+	}
+	
+	public static List<String> split ( String str ) {
+		return Stream.of(str.split(","))
+				.map (elem -> new String(elem))
+				.collect(Collectors.toList());
+	}
+	
+	public static List<Character> splitToListOfChar ( String str ) {
+		return str.chars()
+				.mapToObj(item -> (char) item)
+				.collect(Collectors.toList());
+	}
+		
+}
@@ -8,55 +8,55 @@ public class CharArrayToStringUnitTest {

    @Test
    public void givenCharArray_whenCallingStringConstructor_shouldConvertToString() {
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = new String(charArray);
        String expectedValue = "character";
-        
+
        assertEquals(expectedValue, result);
    }
-    
+
    @Test
-    public void givenCharArray_whenCallingStringConstructorWithOffsetAndLength_shouldConvertToString(){
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+    public void givenCharArray_whenCallingStringConstructorWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = new String(charArray, 4, 3);
        String expectedValue = "act";
-        
+
        assertEquals(expectedValue, result);
    }
-    
+
    @Test
-    public void givenCharArray_whenCallingStringCopyValueOf_shouldConvertToString(){
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+    public void givenCharArray_whenCallingStringCopyValueOf_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = String.copyValueOf(charArray);
        String expectedValue = "character";
-        
+
        assertEquals(expectedValue, result);
    }
-    
+
    @Test
-    public void givenCharArray_whenCallingStringCopyValueOfWithOffsetAndLength_shouldConvertToString(){
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+    public void givenCharArray_whenCallingStringCopyValueOfWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = String.copyValueOf(charArray, 0, 4);
        String expectedValue = "char";
-        
+
        assertEquals(expectedValue, result);
    }
-    
+
    @Test
-    public void givenCharArray_whenCallingStringValueOf_shouldConvertToString(){
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+    public void givenCharArray_whenCallingStringValueOf_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = String.valueOf(charArray);
        String expectedValue = "character";
-        
+
        assertEquals(expectedValue, result);
    }
-    
+
    @Test
-    public void givenCharArray_whenCallingStringValueOfWithOffsetAndLength_shouldConvertToString(){
-        char[] charArray = {'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r'};
+    public void givenCharArray_whenCallingStringValueOfWithOffsetAndLength_shouldConvertToString() {
+        char[] charArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r' };
        String result = String.valueOf(charArray, 3, 4);
        String expectedValue = "ract";
-        
+
        assertEquals(expectedValue, result);
    }
 }
@@ -6,15 +6,15 @@ import org.junit.Test;

 public class StringToCharArrayUnitTest {

-@Test
-public void givenString_whenCallingStringToCharArray_shouldConvertToCharArray() {
-    String givenString = "characters";
+    @Test
+    public void givenString_whenCallingStringToCharArray_shouldConvertToCharArray() {
+        String givenString = "characters";

-    char[] result = givenString.toCharArray();
+        char[] result = givenString.toCharArray();

-    char[] expectedCharArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's' };
+        char[] expectedCharArray = { 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's' };

-    assertArrayEquals(expectedCharArray, result);
-}
+        assertArrayEquals(expectedCharArray, result);
+    }

 }
@@ -1,16 +0,0 @@
-package com.baeldung.algorithms;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import com.baeldung.algorithms.ga.binary.SimpleGeneticAlgorithm;
-
-public class BinaryGeneticAlgorithmTest {
-
-	@Test
-	public void testGA() {
-		Assert.assertTrue(SimpleGeneticAlgorithm.runAlgorithm(50,
-				"1011000100000100010000100000100111001000000100000100000000001111"));
-	}
-
-}
@@ -0,0 +1,16 @@
+package com.baeldung.algorithms;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.ga.binary.SimpleGeneticAlgorithm;
+
+public class BinaryGeneticAlgorithmUnitTest {
+
+	@Test
+	public void testGA() {
+		SimpleGeneticAlgorithm ga = new SimpleGeneticAlgorithm();
+		Assert.assertTrue(ga.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111"));
+	}
+
+}
@@ -32,13 +32,14 @@ public class PriorityBlockingQueueUnitTest {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        final Thread thread = new Thread(() -> {
-          System.out.println("Polling...");
-          while (true) {
-            try {
-              Integer poll = queue.take();
-              System.out.println("Polled: " + poll);
-            } catch (InterruptedException e) {}
-          }
+            System.out.println("Polling...");
+            while (true) {
+                try {
+                    Integer poll = queue.take();
+                    System.out.println("Polled: " + poll);
+                } catch (InterruptedException e) {
+                }
+            }
        });
        thread.start();

@@ -0,0 +1,60 @@
+package com.baeldung.graph;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.neo4j.driver.v1.AuthTokens;
+import org.neo4j.driver.v1.Driver;
+import org.neo4j.driver.v1.GraphDatabase;
+import org.neo4j.driver.v1.Session;
+import org.neo4j.driver.v1.StatementResult;
+import org.testng.Assert;
+
+@Ignore
+public class Neo4JServerTest {
+
+    @Test
+    public void standAloneDriver() {
+        Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "12345"));
+        Session session = driver.session();
+
+        session.run("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
+                "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
+                "RETURN baeldung, tesla");
+
+        StatementResult result = session.run("MATCH (company:Company)-[:owns]-> (car:Car)" +
+                "WHERE car.make='tesla' and car.model='modelX'" +
+                "RETURN company.name");
+
+        Assert.assertTrue(result.hasNext());
+        Assert.assertEquals(result.next().get("company.name").asString(), "Baeldung");
+
+        session.close();
+        driver.close();
+    }
+    
+    @Test
+    public void standAloneJdbc() throws Exception {
+        Connection con = DriverManager.getConnection("jdbc:neo4j:bolt://localhost/?user=neo4j,password=12345,scheme=basic");
+
+        // Querying
+        try (Statement stmt = con.createStatement()) {
+            stmt.execute("CREATE (baeldung:Company {name:\"Baeldung\"}) " +
+                    "-[:owns]-> (tesla:Car {make: 'tesla', model: 'modelX'})" +
+                    "RETURN baeldung, tesla");
+
+            ResultSet rs = stmt.executeQuery("MATCH (company:Company)-[:owns]-> (car:Car)" +
+                    "WHERE car.make='tesla' and car.model='modelX'" +
+                    "RETURN company.name");
+
+            while (rs.next()) {
+                Assert.assertEquals(rs.getString("company.name"), "Baeldung");
+            }
+        }
+        con.close();
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung.graph;
+
+import org.junit.Test;
+import org.neo4j.ogm.config.Configuration;
+import org.neo4j.ogm.model.Result;
+import org.neo4j.ogm.session.Session;
+import org.neo4j.ogm.session.SessionFactory;
+import org.testng.Assert;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Danil Kornishev ([email protected])
+ */
+public class Neo4jOgmTest {
+
+    @Test
+    public void testOgm() {
+        Configuration conf = new Configuration();
+        conf.driverConfiguration().setDriverClassName("org.neo4j.ogm.drivers.embedded.driver.EmbeddedDriver");
+
+        SessionFactory factory = new SessionFactory(conf, "com.baeldung.graph");
+        Session session = factory.openSession();
+
+        Car tesla = new Car("tesla", "modelS");
+        Company baeldung = new Company("baeldung");
+
+        baeldung.setCar(tesla);
+
+        session.save(baeldung);
+
+        Map<String, String> params = new HashMap<>();
+        params.put("make", "tesla");
+        Result result = session.query("MATCH (car:Car) <-[:owns]- (company:Company)" +
+                " WHERE car.make=$make" +
+                " RETURN company", params);
+
+        Map<String, Object> firstResult = result.iterator().next();
+
+        Assert.assertEquals(firstResult.size(), 1);
+
+        Company actual = (Company) firstResult.get("company");
+        Assert.assertEquals(actual.getName(), baeldung.getName());
+    }
+}
--- a/Show More
+++ b/Show More