Add tests for subproject

Author: Jegors Cemisovs

algorithm/build.gradle

@@ -1,4 +1,5 @@
 plugins {
+    id 'groovy'
     id 'java-library'
     id 'maven-publish'
 }
@@ -41,4 +42,22 @@ publishing {
             }
         }
     }
-}
+}
+
+dependencies {
+    // Spock Framework
+    testImplementation 'org.spockframework:spock-core:2.0-groovy-3.0'
+    testImplementation 'org.codehaus.groovy:groovy-all:3.0.9'
+
+    // Spock Reports
+    testRuntimeClasspath( "com.athaydes:spock-reports:2.1.1-groovy-3.0" ) {
+        transitive = false // this avoids affecting your version of Groovy/Spock
+    }
+    // Required for spock-reports
+    testImplementation 'org.slf4j:slf4j-api:1.7.32'
+    testRuntimeClasspath 'org.slf4j:slf4j-simple:1.7.32'
+}
+
+test {
+    useJUnitPlatform()
+}

algorithm/src/test/groovy/lv/id/jc/graph/BreadthFirstSearchSpec.groovy

@@ -0,0 +1,95 @@
+package lv.id.jc.graph
+
+import lv.id.jc.algorithm.graph.BreadthFirstSearch
+import lv.id.jc.algorithm.graph.Graph
+import spock.lang.*
+
+@Title("Breadth First Search Algorithm")
+@See("https://en.wikipedia.org/wiki/Breadth-first_search")
+@Narrative("""
+Breadth First Search algorithm for finding the shortest paths between nodes in a graph
+""")
+class BreadthFirstSearchSpec extends Specification {
+    @Subject
+    def algorithm = new BreadthFirstSearch()
+
+    def 'should find a route for simple graph'() {
+        given: 'A simple graph'
+        def graph = Graph.of([
+                A: [B: 7, C: 2],
+                B: [A: 3, C: 5],
+                C: [A: 1, B: 3]
+        ])
+
+        when: 'we use Breadth First Search algorithm to find a path'
+        def path = algorithm.findPath(graph, source, target)
+
+        then: 'we get the shortest path'
+        path == shortest
+
+        and: 'the distance calculated correctly'
+        graph.getDistance(path) == time as double
+
+        where:
+        source | target || time | shortest
+        'A'    | 'A'    || 0    | ['A']
+        'A'    | 'B'    || 7    | ['A', 'B']
+        'B'    | 'C'    || 5    | ['B', 'C']
+        'C'    | 'B'    || 3    | ['C', 'B']
+    }
+
+    def 'should find a route for complex graph'() {
+        given: 'A complex graph'
+        def graph = Graph.of([
+                A: [B: 1],
+                B: [A: 1, D: 1],
+                C: [A: 1],
+                D: [C: 1, E: 1],
+                E: [F: 1],
+                F: [D: 1, E: 1]])
+
+        when: 'we use Breadth First Search algorithm to find a path'
+        def path = algorithm.findPath(graph, source, target)
+
+        then: 'we get the shortest path'
+        path == shortest
+
+        and: 'the distance calculated correctly'
+        graph.getDistance(path) == time as double
+
+        where:
+        source | target || shortest
+        'A'    | 'A'    || ['A']
+        'B'    | 'B'    || ['B']
+        'A'    | 'B'    || ['A', 'B']
+        'B'    | 'A'    || ['B', 'A']
+        'A'    | 'C'    || ['A', 'B', 'D', 'C']
+        'C'    | 'A'    || ['C', 'A']
+        'E'    | 'B'    || ['E', 'F', 'D', 'C', 'A', 'B']
+
+        and:
+        time = shortest.size() - 1
+    }
+
+    def 'should thrown NPE path for an empty graph'() {
+        given: 'an empty graph'
+        def graph = Graph.of([:])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        algorithm.findPath(graph, 'A', 'B')
+
+        then: 'the exception was thrown'
+        thrown NullPointerException
+    }
+
+    def "should return an empty path if can't find a route"() {
+        given: 'a simple graph with no edge between nodes'
+        def graph = Graph.of([A: [:], B: [:]])
+
+        when: 'we use Breadth First Search algorithm to find a path'
+        def path = algorithm.findPath(graph, 'A', 'B')
+
+        then: 'we get an empty path'
+        path == []
+    }
+}

algorithm/src/test/groovy/lv/id/jc/graph/DijkstrasAlgorithmSpec.groovy

@@ -0,0 +1,127 @@
+package lv.id.jc.graph
+
+import lv.id.jc.algorithm.graph.DijkstrasAlgorithm
+import lv.id.jc.algorithm.graph.Graph
+import spock.lang.*
+
+@Title("Dijkstra's Algorithm")
+@See("https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm")
+@Narrative("Dijkstra's algorithm is an algorithm for finding the fastest paths between nodes in a graph")
+class DijkstrasAlgorithmSpec extends Specification {
+    @Subject
+    def algorithm = new DijkstrasAlgorithm()
+
+    def 'should find a route for a simple graph'() {
+        given: 'A simple graph'
+        def graph = Graph.of([
+                A: [B: 7, C: 2],
+                B: [A: 3, C: 5],
+                C: [A: 1, B: 3]
+        ])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        def path = algorithm.findPath(graph, source, target)
+
+        then: 'we get the fastest way'
+        path == fastest
+
+        and: 'the distance calculated correctly'
+        graph.getDistance(path) == time as double
+
+        where:
+        source | target || time | fastest
+        'A'    | 'A'    || 0    | ['A']
+        'B'    | 'B'    || 0    | ['B']
+        'C'    | 'C'    || 0    | ['C']
+        'A'    | 'B'    || 5    | ['A', 'C', 'B']
+    }
+
+    def 'should find a route for a medium graph'() {
+        given: 'A medium graph'
+        def graph = Graph.of([
+                A: [B: 5],
+                B: [A: 5, C: 10],
+                C: [B: 20, D: 5],
+                D: [E: 5],
+                E: [B: 5]
+        ])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        def path = algorithm.findPath(graph, source, target)
+
+        then: 'we get the fastest way'
+        path == fastest
+
+        and: 'the distance calculated correctly'
+        graph.getDistance(path) == time as double
+
+        where:
+        source | target || time | fastest
+        'A'    | 'A'    || 0    | ['A']
+        'B'    | 'B'    || 0    | ['B']
+        'A'    | 'B'    || 5    | ['A', 'B']
+        'B'    | 'A'    || 5    | ['B', 'A']
+        'A'    | 'C'    || 15   | ['A', 'B', 'C']
+        'C'    | 'A'    || 20   | ['C', 'D', 'E', 'B', 'A']
+    }
+
+    def 'should find a route for a complex graph'() {
+        given: 'A complex graph'
+        def graph = Graph.of([
+                A: [B: 5, H: 2],
+                B: [A: 5, C: 7],
+                C: [B: 7, D: 3, G: 4],
+                D: [C: 20, E: 4],
+                E: [F: 5],
+                F: [G: 6],
+                G: [C: 4],
+                H: [G: 3]
+        ])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        def path = algorithm.findPath(graph, source, target)
+
+        then: 'we get the fastest way'
+        path == fastest
+
+        and: 'the distance calculated correctly'
+        graph.getDistance(path) == time as double
+
+        where:
+        source | target || time | fastest
+        'A'    | 'A'    || 0    | ['A']
+        'B'    | 'B'    || 0    | ['B']
+        'A'    | 'B'    || 5    | ['A', 'B']
+        'B'    | 'A'    || 5    | ['B', 'A']
+        'A'    | 'C'    || 9    | ['A', 'H', 'G', 'C']
+        'C'    | 'A'    || 12   | ['C', 'B', 'A']
+        'A'    | 'G'    || 5    | ['A', 'H', 'G']
+        'C'    | 'D'    || 3    | ['C', 'D']
+        'D'    | 'C'    || 19   | ['D', 'E', 'F', 'G', 'C']
+        'B'    | 'D'    || 10   | ['B', 'C', 'D']
+        'D'    | 'B'    || 26   | ['D', 'E', 'F', 'G', 'C', 'B']
+        'D'    | 'H'    || 33   | ['D', 'E', 'F', 'G', 'C', 'B', 'A', 'H']
+    }
+
+    def 'should thrown NPE for an empty graph'() {
+        given: 'an empty graph'
+        def graph = Graph.of([:])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        algorithm.findPath(graph, 'A', 'B')
+
+        then: 'the exception was thrown'
+        thrown NullPointerException
+    }
+
+    def "should return an empty path if can't find a route"() {
+        given: 'a simple graph with no edge between nodes'
+        def graph = Graph.of([A: [:], B: [:]])
+
+        when: "we use Dijkstra's algorithm to find a path"
+        def path = algorithm.findPath(graph, 'A', 'B')
+
+        then: 'we get an empty path'
+        path == []
+    }
+}

algorithm/src/test/groovy/lv/id/jc/graph/GraphSpec.groovy

@@ -0,0 +1,100 @@
+package lv.id.jc.graph
+
+import lv.id.jc.algorithm.graph.Graph
+import spock.lang.Narrative
+import spock.lang.Specification
+import spock.lang.Title
+
+@Title("Generic Graph")
+@Narrative("A generic implementation of Graph structure")
+class GraphSpec extends Specification {
+
+    def "should return edges for a given node"() {
+        given: 'a simple graph with three nodes'
+        def graph = Graph.of([
+                A: [B: 7, C: 2],
+                B: [A: 3, C: 5],
+                C: [A: 1, B: 3]
+        ])
+
+        expect: 'The method returns expected edges for given node'
+        graph.edges(node) == expected
+
+        where:
+        node | expected
+        'A'  | [B: 7, C: 2]
+        'B'  | [A: 3, C: 5]
+        'C'  | [A: 1, B: 3]
+    }
+
+    def 'should calculate distance for a path'() {
+        given: "a complex graph with eight nodes"
+        def graph = Graph.of([
+                A: [B: 5, H: 2],
+                B: [A: 5, C: 7],
+                C: [B: 7, D: 3, G: 4],
+                D: [C: 20, E: 4],
+                E: [F: 5],
+                F: [G: 6],
+                G: [C: 4],
+                H: [G: 3]
+        ])
+
+        expect: 'the distance for a path correctly calculated'
+        graph.getDistance(path) == distance as double
+
+        where: 'path and expected distance'
+        path                      | distance
+        ['A']                     | 0
+        ['A', 'B']                | 5
+        ['B', 'A']                | 5
+        ['A', 'B', 'A']           | 10
+        ['A', 'B', 'A', 'B']      | 15
+        ['C', 'D']                | 3
+        ['D', 'C']                | 20
+        ['D', 'E', 'F', 'G', 'C'] | 19
+    }
+
+    def 'should be zero distance for an empty path'() {
+        given: 'any graph'
+        def graph = Graph.of(_ as Map)
+
+        expect: 'the distance is zero for an empty path'
+        graph.getDistance([]) == 0
+    }
+
+    def 'should be zero distance for any one node path'() {
+        given: 'any graph'
+        def graph = Graph.of(_ as Map)
+
+        expect: 'the zero distance for any one-node path'
+        graph.getDistance(oneNodePath) == 0
+
+        where: 'the node may be of any type and even non-existent'
+        oneNodePath << [
+                ['A'], ['B'], [2], ['X' as char], [12.56]
+        ]
+    }
+
+    def 'should throw NPE for incorrect path'() {
+        given: "a medium graph with five nodes"
+        def graph = Graph.of([
+                A: [B: 5],
+                B: [A: 5, C: 10],
+                C: [B: 20, D: 5],
+                D: [E: 5],
+                E: [B: 5]
+        ])
+
+        when: 'we call the method with incorrect path'
+        graph.getDistance(incorrectPath)
+
+        then: 'the NPE thrown'
+        thrown NullPointerException
+
+        where: 'path is more then one node'
+        incorrectPath << [
+                ['E', 'D'], ['A', 'C'], ['A', 'B', 'D']
+        ]
+    }
+}