fix package, fix get random node

2018-08-25 20:36:12 +03:00
parent f60debdcd3
commit aa8afa5b6e
13 changed files with 13 additions and 13 deletions
@@ -0,0 +1,22 @@
+package com.baeldung.algorithms;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.ga.ant_colony.AntColonyOptimization;
+
+public class AntColonyOptimizationLongRunningUnitTest {
+
+    @Test
+    public void testGenerateRandomMatrix() {
+        AntColonyOptimization antTSP = new AntColonyOptimization(5);
+        Assert.assertNotNull(antTSP.generateRandomMatrix(5));
+    }
+
+    @Test
+    public void testStartAntOptimization() {
+        AntColonyOptimization antTSP = new AntColonyOptimization(5);
+        Assert.assertNotNull(antTSP.solve());
+    }
+
+}
@@ -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 BinaryGeneticAlgorithmLongRunningUnitTest {
+
+    @Test
+    public void testGA() {
+        SimpleGeneticAlgorithm ga = new SimpleGeneticAlgorithm();
+        Assert.assertTrue(ga.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111"));
+    }
+
+}
@@ -0,0 +1,86 @@
+package com.baeldung.algorithms;
+
+import org.junit.Test;
+
+import com.baeldung.algorithms.ga.dijkstra.Dijkstra;
+import com.baeldung.algorithms.ga.dijkstra.Graph;
+import com.baeldung.algorithms.ga.dijkstra.Node;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class DijkstraAlgorithmLongRunningUnitTest {
+
+    @Test
+    public void whenSPPSolved_thenCorrect() {
+
+        Node nodeA = new Node("A");
+        Node nodeB = new Node("B");
+        Node nodeC = new Node("C");
+        Node nodeD = new Node("D");
+        Node nodeE = new Node("E");
+        Node nodeF = new Node("F");
+
+        nodeA.addDestination(nodeB, 10);
+        nodeA.addDestination(nodeC, 15);
+
+        nodeB.addDestination(nodeD, 12);
+        nodeB.addDestination(nodeF, 15);
+
+        nodeC.addDestination(nodeE, 10);
+
+        nodeD.addDestination(nodeE, 2);
+        nodeD.addDestination(nodeF, 1);
+
+        nodeF.addDestination(nodeE, 5);
+
+        Graph graph = new Graph();
+
+        graph.addNode(nodeA);
+        graph.addNode(nodeB);
+        graph.addNode(nodeC);
+        graph.addNode(nodeD);
+        graph.addNode(nodeE);
+        graph.addNode(nodeF);
+
+        graph = Dijkstra.calculateShortestPathFromSource(graph, nodeA);
+
+        List<Node> shortestPathForNodeB = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeC = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeD = Arrays.asList(nodeA, nodeB);
+        List<Node> shortestPathForNodeE = Arrays.asList(nodeA, nodeB, nodeD);
+        List<Node> shortestPathForNodeF = Arrays.asList(nodeA, nodeB, nodeD);
+
+        for (Node node : graph.getNodes()) {
+            switch (node.getName()) {
+            case "B":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeB));
+                break;
+            case "C":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeC));
+                break;
+            case "D":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeD));
+                break;
+            case "E":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeE));
+                break;
+            case "F":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeF));
+                break;
+            }
+        }
+    }
+}
@@ -0,0 +1,58 @@
+package com.baeldung.algorithms;
+
+import com.baeldung.algorithms.hillclimbing.HillClimbing;
+import com.baeldung.algorithms.hillclimbing.State;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class HillClimbingAlgorithmUnitTest {
+    private Stack<String> initStack;
+    private Stack<String> goalStack;
+
+    @Before
+    public void initStacks() {
+        String blockArr[] = { "B", "C", "D", "A" };
+        String goalBlockArr[] = { "A", "B", "C", "D" };
+        initStack = new Stack<>();
+        for (String block : blockArr)
+            initStack.push(block);
+        goalStack = new Stack<>();
+        for (String block : goalBlockArr)
+            goalStack.push(block);
+    }
+
+    @Test
+    public void givenInitAndGoalState_whenGetPathWithHillClimbing_thenPathFound() {
+        HillClimbing hillClimbing = new HillClimbing();
+
+        List<State> path;
+        try {
+            path = hillClimbing.getRouteWithHillClimbing(initStack, goalStack);
+            assertNotNull(path);
+            assertEquals(path.get(path.size() - 1)
+                .getState()
+                .get(0), goalStack);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenCurrentState_whenFindNextState_thenBetterHeuristics() {
+        HillClimbing hillClimbing = new HillClimbing();
+        List<Stack<String>> initList = new ArrayList<>();
+        initList.add(initStack);
+        State currentState = new State(initList);
+        currentState.setHeuristics(hillClimbing.getHeuristicsValue(initList, goalStack));
+        State nextState = hillClimbing.findNextState(currentState, goalStack);
+        assertTrue(nextState.getHeuristics() > currentState.getHeuristics());
+    }
+}
@@ -0,0 +1,118 @@
+package com.baeldung.algorithms;
+
+import com.baeldung.algorithms.middleelementlookup.MiddleElementLookup;
+import com.baeldung.algorithms.middleelementlookup.Node;
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class MiddleElementLookupUnitTest {
+
+    @Test
+    public void whenFindingMiddleLinkedList_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenListEmptyOrNull_thenMiddleNotFound() {
+        // null list
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(null)
+          .isPresent());
+
+        // empty LinkedList
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(new LinkedList<>())
+          .isPresent());
+
+        // LinkedList with nulls
+        LinkedList<String> nullsList = new LinkedList<>();
+        nullsList.add(null);
+        nullsList.add(null);
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(nullsList)
+          .isPresent());
+
+        // nodes with null values
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(new Node(null))
+          .isPresent());
+    }
+
+    private static LinkedList<String> createLinkedList(int n) {
+        LinkedList<String> list = new LinkedList<>();
+
+        for (int i = 1; i <= n; i++) {
+            list.add(String.valueOf(i));
+        }
+
+        return list;
+    }
+
+    private static Node createNodesList(int n) {
+        Node head = new Node("1");
+        Node current = head;
+
+        for (int i = 2; i <= n; i++) {
+            Node newNode = new Node(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
+}
@@ -0,0 +1,73 @@
+package com.baeldung.algorithms;
+
+import com.baeldung.algorithms.automata.*;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public final class RtFiniteStateMachineLongRunningUnitTest {
+
+    @Test
+    public void acceptsSimplePair() {
+        String json = "{\"key\":\"value\"}";
+        FiniteStateMachine machine = this.buildJsonStateMachine();
+        for (int i = 0; i < json.length(); i++) {
+            machine = machine.switchState(String.valueOf(json.charAt(i)));
+        }
+        assertTrue(machine.canStop());
+    }
+
+    @Test
+    public void acceptsMorePairs() {
+        String json = "{\"key1\":\"value1\",\"key2\":\"value2\"}";
+        FiniteStateMachine machine = this.buildJsonStateMachine();
+        for (int i = 0; i < json.length(); i++) {
+            machine = machine.switchState(String.valueOf(json.charAt(i)));
+        }
+        assertTrue(machine.canStop());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void missingColon() {
+        String json = "{\"key\"\"value\"}";
+        FiniteStateMachine machine = this.buildJsonStateMachine();
+        for (int i = 0; i < json.length(); i++) {
+            machine = machine.switchState(String.valueOf(json.charAt(i)));
+        }
+    }
+
+    /**
+     * Builds a finite state machine to validate a simple
+     * Json object.
+     * @return
+     */
+    private FiniteStateMachine buildJsonStateMachine() {
+        State first = new RtState();
+        State second = new RtState();
+        State third = new RtState();
+        State fourth = new RtState();
+        State fifth = new RtState();
+        State sixth = new RtState();
+        State seventh = new RtState();
+        State eighth = new RtState(true);
+
+        first.with(new RtTransition("{", second));
+        second.with(new RtTransition("\"", third));
+        //Add transitions with chars 0-9 and a-z
+        for (int i = 0; i < 26; i++) {
+            if (i < 10) {
+                third = third.with(new RtTransition(String.valueOf(i), third));
+                sixth = sixth.with(new RtTransition(String.valueOf(i), sixth));
+            }
+            third = third.with(new RtTransition(String.valueOf((char) ('a' + i)), third));
+            sixth = sixth.with(new RtTransition(String.valueOf((char) ('a' + i)), sixth));
+        }
+        third.with(new RtTransition("\"", fourth));
+        fourth.with(new RtTransition(":", fifth));
+        fifth.with(new RtTransition("\"", sixth));
+        sixth.with(new RtTransition("\"", seventh));
+        seventh.with(new RtTransition(",", second));
+        seventh.with(new RtTransition("}", eighth));
+        return new RtFiniteStateMachine(first);
+    }
+}
@@ -0,0 +1,15 @@
+package com.baeldung.algorithms;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.ga.annealing.SimulatedAnnealing;
+
+public class SimulatedAnnealingLongRunningUnitTest {
+
+    @Test
+    public void testSimulateAnnealing() {
+        Assert.assertTrue(SimulatedAnnealing.simulateAnnealing(10, 1000, 0.9) > 0);
+    }
+
+}
@@ -0,0 +1,25 @@
+package com.baeldung.algorithms;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
+
+public class StringSearchAlgorithmsUnitTest {
+	
+	
+	@Test
+	public void testStringSearchAlgorithms(){
+		String text = "This is some nice text.";
+		String pattern = "some";
+		
+		int realPosition = text.indexOf(pattern);
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.simpleTextSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.RabinKarpMethod(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.KnuthMorrisPrattSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSimpleSearch(pattern.toCharArray(), text.toCharArray()));
+        Assert.assertTrue(realPosition == StringSearchAlgorithms.BoyerMooreHorspoolSearch(pattern.toCharArray(), text.toCharArray()));
+	}
+
+}
@@ -0,0 +1,43 @@
+package com.baeldung.algorithms.binarysearch;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import com.baeldung.algorithms.binarysearch.BinarySearch;
+
+public class BinarySearchUnitTest {
+
+    int[] sortedArray = { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+    int key = 6;
+    int expectedIndexForSearchKey = 7;
+    int low = 0;
+    int high = sortedArray.length - 1;
+    List<Integer> sortedList = Arrays.asList(0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9);
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunIterativelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchIteratively(sortedArray, key, low, high));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunRecursivelyForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchRecursively(sortedArray, key, low, high));
+    }
+    
+    @Test
+    public void givenASortedArrayOfIntegers_whenBinarySearchRunUsingArraysClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaArrays(sortedArray, key));
+    }
+    
+    @Test
+    public void givenASortedListOfIntegers_whenBinarySearchRunUsingCollectionsClassStaticMethodForANumber_thenGetIndexOfTheNumber() {
+        BinarySearch binSearch = new BinarySearch();
+        Assert.assertEquals(expectedIndexForSearchKey, binSearch.runBinarySearchUsingJavaCollections(sortedList, key));
+    }
+    
+}
@@ -0,0 +1,92 @@
+package com.baeldung.algorithms.mcts;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.baeldung.algorithms.mcts.montecarlo.MonteCarloTreeSearch;
+import com.baeldung.algorithms.mcts.montecarlo.State;
+import com.baeldung.algorithms.mcts.montecarlo.UCT;
+import com.baeldung.algorithms.mcts.tictactoe.Board;
+import com.baeldung.algorithms.mcts.tictactoe.Position;
+import com.baeldung.algorithms.mcts.tree.Tree;
+
+public class MCTSUnitTest {
+    private Tree gameTree;
+    private MonteCarloTreeSearch mcts;
+
+    @Before
+    public void initGameTree() {
+        gameTree = new Tree();
+        mcts = new MonteCarloTreeSearch();
+    }
+
+    @Test
+    public void givenStats_whenGetUCTForNode_thenUCTMatchesWithManualData() {
+        double uctValue = 15.79;
+        assertEquals(UCT.uctValue(600, 300, 20), uctValue, 0.01);
+    }
+
+    @Test
+    public void giveninitBoardState_whenGetAllPossibleStates_thenNonEmptyList() {
+        State initState = gameTree.getRoot().getState();
+        List<State> possibleStates = initState.getAllPossibleStates();
+        assertTrue(possibleStates.size() > 0);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenPerformMove_thenLessAvailablePossitions() {
+        Board board = new Board();
+        int initAvailablePositions = board.getEmptyPositions().size();
+        board.performMove(Board.P1, new Position(1, 1));
+        int availablePositions = board.getEmptyPositions().size();
+        assertTrue(initAvailablePositions > availablePositions);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenSimulateInterAIPlay_thenGameDraw() {
+        Board board = new Board();
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            board = mcts.findNextMove(board, player);
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertEquals(winStatus, Board.DRAW);
+    }
+
+    @Test
+    public void givenEmptyBoard_whenLevel1VsLevel3_thenLevel3WinsOrDraw() {
+        Board board = new Board();
+        MonteCarloTreeSearch mcts1 = new MonteCarloTreeSearch();
+        mcts1.setLevel(1);
+        MonteCarloTreeSearch mcts3 = new MonteCarloTreeSearch();
+        mcts3.setLevel(3);
+
+        int player = Board.P1;
+        int totalMoves = Board.DEFAULT_BOARD_SIZE * Board.DEFAULT_BOARD_SIZE;
+        for (int i = 0; i < totalMoves; i++) {
+            if (player == Board.P1)
+                board = mcts3.findNextMove(board, player);
+            else
+                board = mcts1.findNextMove(board, player);
+
+            if (board.checkStatus() != -1) {
+                break;
+            }
+            player = 3 - player;
+        }
+        int winStatus = board.checkStatus();
+        assertTrue(winStatus == Board.DRAW || winStatus == Board.P1);
+    }
+
+}
@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.minimax;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import com.baeldung.algorithms.minimax.MiniMax;
+import com.baeldung.algorithms.minimax.Tree;
+
+public class MinimaxUnitTest {
+    private Tree gameTree;
+    private MiniMax miniMax;
+
+    @Before
+    public void initMiniMaxUtility() {
+        miniMax = new MiniMax();
+    }
+
+    @Test
+    public void givenMiniMax_whenConstructTree_thenNotNullTree() {
+        assertNull(gameTree);
+        miniMax.constructTree(6);
+        gameTree = miniMax.getTree();
+        assertNotNull(gameTree);
+    }
+
+    @Test
+    public void givenMiniMax_whenCheckWin_thenComputeOptimal() {
+        miniMax.constructTree(6);
+        boolean result = miniMax.checkWin();
+        assertTrue(result);
+        miniMax.constructTree(8);
+        result = miniMax.checkWin();
+        assertFalse(result);
+    }
+}