/* Labeled Digraph ADT, Using Scala HashMap, Test Driver
   CSci 555: Functional Programming, Spring 2019
   H. Conrad Cunningham, Professor
   Computer and Information Science
   University of Mississippi

1234567890123456789012345678901234567890123456789012345678901234567890

2016-03-08: Developed Scala verson from 2015 Elixir version and
            2016 Scala List version
2019-03-21: Ensured worked with revised Digraph and DigrqphMap

TODO: Replace + for string concatention by interpolated strings

*/

object Test_DigraphMap {

  // Main method for testing
  def main(args: Array[String]) {
 
    val g0: DigraphMap[Int,Int,Int] = new DigraphMap()
    println("g0 = new DigraphMap()       ==> " + g0)
    println("g0.isEmpty                  ==> " + g0.isEmpty)
    println("g0.hasVertex(1)             ==> " + g0.hasVertex(1))
    println("g0.hasVertex(2)             ==> " + g0.hasVertex(2))
    println("g0.hasVertex(3)             ==> " + g0.hasVertex(3))

    println("g0.hasEdge(1,1)             ==> " + g0.hasEdge(1,1))
    println("g0.hasEdge(2,2)             ==> " + g0.hasEdge(2,2))
    println("g0.hasEdge(3,3)             ==> " + g0.hasEdge(3,3))
    println("g0.hasEdge(1,2)             ==> " + g0.hasEdge(1,2))
    println("g0.hasEdge(2,1)             ==> " + g0.hasEdge(2,1))
    println("g0.hasEdge(2,3)             ==> " + g0.hasEdge(2,3))
    println("g0.hasEdge(3,2)             ==> " + g0.hasEdge(3,2))
    println("g0.hasEdge(1,3)             ==> " + g0.hasEdge(1,3))
    println("g0.hasEdge(3,1)             ==> " + g0.hasEdge(3,1))

    println("g0.allVertices              ==> " + g0.allVertices)
    println("g0.allVerticesLabels        ==> " + g0.allVerticesLabels)
    println("g0.fromEdges(1)             ==> " + g0.fromEdges(1))
    println("g0.fromEdges(2)             ==> " + g0.fromEdges(2))
    println("g0.fromEdges(3)             ==> " + g0.fromEdges(3))
    println("g0.fromEdgesLabels(1)       ==> " + g0.fromEdgesLabels(1))
    println("g0.fromEdgesLabels(2)       ==> " + g0.fromEdgesLabels(2))
    println("g0.fromEdgesLabels(3)       ==> " + g0.fromEdgesLabels(3))
    println("\n")

    val g1 = g0.addVertex(1, 101)
    println("g1 = g0.addVertex(1, 101)   ==> " + g1)
    println("g1.isEmpty                  ==> " + g1.isEmpty)
    println("g1.hasVertex(1)             ==> " + g1.hasVertex(1))
    println("g1.hasVertex(2)             ==> " + g1.hasVertex(2))
    println("g1.hasVertex(3)             ==> " + g1.hasVertex(3))

    println("g1.hasEdge(1,1)             ==> " + g1.hasEdge(1,1))
    println("g1.hasEdge(2,2)             ==> " + g1.hasEdge(2,2))
    println("g1.hasEdge(3,3)             ==> " + g1.hasEdge(3,3))
    println("g1.hasEdge(1,2)             ==> " + g1.hasEdge(1,2))
    println("g1.hasEdge(2,1)             ==> " + g1.hasEdge(2,1))
    println("g1.hasEdge(2,3)             ==> " + g1.hasEdge(2,3))
    println("g1.hasEdge(3,2)             ==> " + g1.hasEdge(3,2))
    println("g1.hasEdge(1,3)             ==> " + g1.hasEdge(1,3))
    println("g1.hasEdge(3,1)             ==> " + g1.hasEdge(3,1))

    println("g1.allVertices              ==> " + g1.allVertices)
    println("g1.allVerticesLabels        ==> " + g1.allVerticesLabels)
    println("g1.fromEdges(1)             ==> " + g1.fromEdges(1))
    println("g1.fromEdges(2)             ==> " + g1.fromEdges(2))
    println("g1.fromEdges(3)             ==> " + g1.fromEdges(3))
    println("g1.fromEdgesLabels(1)       ==> " + g1.fromEdgesLabels(1))
    println("g1.fromEdgesLabels(2)       ==> " + g1.fromEdgesLabels(2))
    println("g1.fromEdgesLabels(3)       ==> " + g1.fromEdgesLabels(3))
    println("\n")

    val g2 = g1.addVertex(2, 102)
    println("g2 = g1.addVertex(2, 102)   ==> " + g2)
    println("g2.isEmpty                  ==> " + g2.isEmpty)
    println("g2.hasVertex(1)             ==> " + g2.hasVertex(1))
    println("g2.hasVertex(2)             ==> " + g2.hasVertex(2))
    println("g2.hasVertex(3)             ==> " + g2.hasVertex(3))

    println("g2.hasEdge(1,1)             ==> " + g2.hasEdge(1,1))
    println("g2.hasEdge(2,2)             ==> " + g2.hasEdge(2,2))
    println("g2.hasEdge(3,3)             ==> " + g2.hasEdge(3,3))
    println("g2.hasEdge(1,2)             ==> " + g2.hasEdge(1,2))
    println("g2.hasEdge(2,1)             ==> " + g2.hasEdge(2,1))
    println("g2.hasEdge(2,3)             ==> " + g2.hasEdge(2,3))
    println("g2.hasEdge(3,2)             ==> " + g2.hasEdge(3,2))
    println("g2.hasEdge(1,3)             ==> " + g2.hasEdge(1,3))
    println("g2.hasEdge(3,1)             ==> " + g2.hasEdge(3,1))

    println("g2.allVertices              ==> " + g2.allVertices)
    println("g2.allVerticesLabels        ==> " + g2.allVerticesLabels)
    println("g2.fromEdges(1)             ==> " + g2.fromEdges(1))
    println("g2.fromEdges(2)             ==> " + g2.fromEdges(2))
    println("g2.fromEdges(3)             ==> " + g2.fromEdges(3))
    println("g2.fromEdgesLabels(1)       ==> " + g2.fromEdgesLabels(1))
    println("g2.fromEdgesLabels(2)       ==> " + g2.fromEdgesLabels(2))
    println("g2.fromEdgesLabels(3)       ==> " + g2.fromEdgesLabels(3))
    println("\n")
    
    val g3  = g2.addVertex(3, 103)
    println("g3 = g2.addVertex(3, 103)   ==> " + g3)
    println("g3.isEmpty                  ==> " + g3.isEmpty)
    println("g3.hasVertex(1)             ==> " + g3.hasVertex(1))
    println("g3.hasVertex(2)             ==> " + g3.hasVertex(2))
    println("g3.hasVertex(3)             ==> " + g3.hasVertex(3))

    println("g3.hasEdge(1,1)             ==> " + g3.hasEdge(1,1))
    println("g3.hasEdge(2,2)             ==> " + g3.hasEdge(2,2))
    println("g3.hasEdge(3,3)             ==> " + g3.hasEdge(3,3))
    println("g3.hasEdge(1,2)             ==> " + g3.hasEdge(1,2))
    println("g3.hasEdge(2,1)             ==> " + g3.hasEdge(2,1))
    println("g3.hasEdge(2,3)             ==> " + g3.hasEdge(2,3))
    println("g3.hasEdge(3,2)             ==> " + g3.hasEdge(3,2))
    println("g3.hasEdge(1,3)             ==> " + g3.hasEdge(1,3))
    println("g3.hasEdge(3,1)             ==> " + g3.hasEdge(3,1))

    println("g3.allVertices              ==> " + g3.allVertices)
    println("g3.allVerticesLabels        ==> " + g3.allVerticesLabels)
    println("g3.fromEdges(1)             ==> " + g3.fromEdges(1))
    println("g3.fromEdges(2)             ==> " + g3.fromEdges(2))
    println("g3.fromEdges(3)             ==> " + g3.fromEdges(3))
    println("g3.fromEdgesLabels(1)       ==> " + g3.fromEdgesLabels(1))
    println("g3.fromEdgesLabels(2)       ==> " + g3.fromEdgesLabels(2))
    println("g3.fromEdgesLabels(3)       ==> " + g3.fromEdgesLabels(3))
    println("\n")

    val g4 = g3.addEdge(1, 2, 1002)
    println("g4 = g3.addEdge(1, 2, 1002) ==> " + g4)
    println("g4.isEmpty                  ==> " + g4.isEmpty)
    println("g4.hasVertex(1)             ==> " + g4.hasVertex(1))
    println("g4.hasVertex(2)             ==> " + g4.hasVertex(2))
    println("g4.hasVertex(3)             ==> " + g4.hasVertex(3))

    println("g4.hasEdge(1,1)             ==> " + g4.hasEdge(1,1))
    println("g4.hasEdge(2,2)             ==> " + g4.hasEdge(2,2))
    println("g4.hasEdge(3,3)             ==> " + g4.hasEdge(3,3))
    println("g4.hasEdge(1,2)             ==> " + g4.hasEdge(1,2))
    println("g4.hasEdge(2,1)             ==> " + g4.hasEdge(2,1))
    println("g4.hasEdge(2,3)             ==> " + g4.hasEdge(2,3))
    println("g4.hasEdge(3,2)             ==> " + g4.hasEdge(3,2))
    println("g4.hasEdge(1,3)             ==> " + g4.hasEdge(1,3))
    println("g4.hasEdge(3,1)             ==> " + g4.hasEdge(3,1))

    println("g4.allVertices              ==> " + g4.allVertices)
    println("g4.allVerticesLabels        ==> " + g4.allVerticesLabels)
    println("g4.fromEdges(1)             ==> " + g4.fromEdges(1))
    println("g4.fromEdges(2)             ==> " + g4.fromEdges(2))
    println("g4.fromEdges(3)             ==> " + g4.fromEdges(3))
    println("g4.fromEdgesLabels(1)       ==> " + g4.fromEdgesLabels(1))
    println("g4.fromEdgesLabels(2)       ==> " + g4.fromEdgesLabels(2))
    println("g4.fromEdgesLabels(3)       ==> " + g4.fromEdgesLabels(3))
    println("\n")

    val g5 = g4.addEdge(2, 3, 2003)
    println("g5 = g4.addEdge(2, 3, 2003) ==> " + g5)
    println("g5.isEmpty                  ==> " + g5.isEmpty)
    println("g5.hasVertex(1)             ==> " + g5.hasVertex(1))
    println("g5.hasVertex(2)             ==> " + g5.hasVertex(2))
    println("g5.hasVertex(3)             ==> " + g5.hasVertex(3))

    println("g5.hasEdge(1,1)             ==> " + g5.hasEdge(1,1))
    println("g5.hasEdge(2,2)             ==> " + g5.hasEdge(2,2))
    println("g5.hasEdge(3,3)             ==> " + g5.hasEdge(3,3))
    println("g5.hasEdge(1,2)             ==> " + g5.hasEdge(1,2))
    println("g5.hasEdge(2,1)             ==> " + g5.hasEdge(2,1))
    println("g5.hasEdge(2,3)             ==> " + g5.hasEdge(2,3))
    println("g5.hasEdge(3,2)             ==> " + g5.hasEdge(3,2))
    println("g5.hasEdge(1,3)             ==> " + g5.hasEdge(1,3))
    println("g5.hasEdge(3,1)             ==> " + g5.hasEdge(3,1))

    println("g5.allVertices              ==> " + g5.allVertices)
    println("g5.allVerticesLabels        ==> " + g5.allVerticesLabels)
    println("g5.fromEdges(1)             ==> " + g5.fromEdges(1))
    println("g5.fromEdges(2)             ==> " + g5.fromEdges(2))
    println("g5.fromEdges(3)             ==> " + g5.fromEdges(3))
    println("g5.fromEdgesLabels(1)       ==> " + g5.fromEdgesLabels(1))
    println("g5.fromEdgesLabels(2)       ==> " + g5.fromEdgesLabels(2))
    println("g5.fromEdgesLabels(3)       ==> " + g5.fromEdgesLabels(3))
    println("\n")
    
    val g6 = g5.addEdge(3, 2, 3002)
    println("g6 = g5.addEdge(3, 2, 3002) ==> " + g6)
    println("g6.isEmpty                  ==> " + g6.isEmpty)
    println("g6.hasVertex(1)             ==> " + g6.hasVertex(1))
    println("g6.hasVertex(2)             ==> " + g6.hasVertex(2))
    println("g6.hasVertex(3)             ==> " + g6.hasVertex(3))

    println("g6.hasEdge(1,1)             ==> " + g6.hasEdge(1,1))
    println("g6.hasEdge(2,2)             ==> " + g6.hasEdge(2,2))
    println("g6.hasEdge(3,3)             ==> " + g6.hasEdge(3,3))
    println("g6.hasEdge(1,2)             ==> " + g6.hasEdge(1,2))
    println("g6.hasEdge(2,1)             ==> " + g6.hasEdge(2,1))
    println("g6.hasEdge(2,3)             ==> " + g6.hasEdge(2,3))
    println("g6.hasEdge(3,2)             ==> " + g6.hasEdge(3,2))
    println("g6.hasEdge(1,3)             ==> " + g6.hasEdge(1,3))
    println("g6.hasEdge(3,1)             ==> " + g6.hasEdge(3,1))

    println("g6.allVertices              ==> " + g6.allVertices)
    println("g6.allVerticesLabels        ==> " + g6.allVerticesLabels)
    println("g6.fromEdges(1)             ==> " + g6.fromEdges(1))
    println("g6.fromEdges(2)             ==> " + g6.fromEdges(2))
    println("g6.fromEdges(3)             ==> " + g6.fromEdges(3))
    println("g6.fromEdgesLabels(1)       ==> " + g6.fromEdgesLabels(1))
    println("g6.fromEdgesLabels(2)       ==> " + g6.fromEdgesLabels(2))
    println("g6.fromEdgesLabels(3)       ==> " + g6.fromEdgesLabels(3))
    println("\n")
    
    val g7  = g6.addEdge(3, 1, 3001)
    println("g7 = g6.addEdge(3, 1, 3001) ==> " + g7)
    println("g7.isEmpty                  ==> " + g7.isEmpty)
    println("g7.hasVertex(1)             ==> " + g7.hasVertex(1))
    println("g7.hasVertex(2)             ==> " + g7.hasVertex(2))
    println("g7.hasVertex(3)             ==> " + g7.hasVertex(3))

    println("g7.hasEdge(1,1)             ==> " + g7.hasEdge(1,1))
    println("g7.hasEdge(2,2)             ==> " + g7.hasEdge(2,2))
    println("g7.hasEdge(3,3)             ==> " + g7.hasEdge(3,3))
    println("g7.hasEdge(1,2)             ==> " + g7.hasEdge(1,2))
    println("g7.hasEdge(2,1)             ==> " + g7.hasEdge(2,1))
    println("g7.hasEdge(2,3)             ==> " + g7.hasEdge(2,3))
    println("g7.hasEdge(3,2)             ==> " + g7.hasEdge(3,2))
    println("g7.hasEdge(1,3)             ==> " + g7.hasEdge(1,3))
    println("g7.hasEdge(3,1)             ==> " + g7.hasEdge(3,1))

    println("g7.allVertices              ==> " + g7.allVertices)
    println("g7.allVerticesLabels        ==> " + g7.allVerticesLabels)
    println("g7.fromEdges(1)             ==> " + g7.fromEdges(1))
    println("g7.fromEdges(2)             ==> " + g7.fromEdges(2))
    println("g7.fromEdges(3)             ==> " + g7.fromEdges(3))
    println("g7.fromEdgesLabels(1)       ==> " + g7.fromEdgesLabels(1))
    println("g7.fromEdgesLabels(2)       ==> " + g7.fromEdgesLabels(2))
    println("g7.fromEdgesLabels(3)       ==> " + g7.fromEdgesLabels(3))
    println("\n")
    
    val g8  = g7.addEdge(3, 3, 3003)
    println("g8 = g7.addEdge(3, 3, 3003) ==> " + g8)
    println("g8.isEmpty                  ==> " + g8.isEmpty)
    println("g8.hasVertex(1)             ==> " + g8.hasVertex(1))
    println("g8.hasVertex(2)             ==> " + g8.hasVertex(2))
    println("g8.hasVertex(3)             ==> " + g8.hasVertex(3))

    println("g8.hasEdge(1,1)             ==> " + g8.hasEdge(1,1))
    println("g8.hasEdge(2,2)             ==> " + g8.hasEdge(2,2))
    println("g8.hasEdge(3,3)             ==> " + g8.hasEdge(3,3))
    println("g8.hasEdge(1,2)             ==> " + g8.hasEdge(1,2))
    println("g8.hasEdge(2,1)             ==> " + g8.hasEdge(2,1))
    println("g8.hasEdge(2,3)             ==> " + g8.hasEdge(2,3))
    println("g8.hasEdge(3,2)             ==> " + g8.hasEdge(3,2))
    println("g8.hasEdge(1,3)             ==> " + g8.hasEdge(1,3))
    println("g8.hasEdge(3,1)             ==> " + g8.hasEdge(3,1))

    println("g8.allVertices              ==> " + g8.allVertices)
    println("g8.allVerticesLabels        ==> " + g8.allVerticesLabels)
    println("g8.fromEdges(1)             ==> " + g8.fromEdges(1))
    println("g8.fromEdges(2)             ==> " + g8.fromEdges(2))
    println("g8.fromEdges(3)             ==> " + g8.fromEdges(3))
    println("g8.fromEdgesLabels(1)       ==> " + g8.fromEdgesLabels(1))
    println("g8.fromEdgesLabels(2)       ==> " + g8.fromEdgesLabels(2))
    println("g8.fromEdgesLabels(3)       ==> " + g8.fromEdgesLabels(3))
    println("\n")

    println("\nGets and removes")

    val v2 = g8.getVertexLabel(2)
    println("g8.getVertexLabel(2)       ==> " + v2)

    val e12 = g8.getEdgeLabel(1,2)
    println("g8.getEdgeLabel(1,2)       ==> " + e12)

    val g9 = g8.updateVertex(2,112)
    println("g9 = g8.updateVertex(2,112)==> " + g9)
    println("g9.getVertexLabel(2)       ==> " + g9.getVertexLabel(2))
    println("\n")

    val ga = g9.updateEdge(1,2,122)
    println("ga = g9.updateEdge(1,2,122)==> " + ga)
    println("ga.getEdgeLabel(1,2)       ==> " + ga.getEdgeLabel(1,2))
    println("\n")

    val gb = ga.removeEdge(1,2)
    println("gb = ga.removeEdge(1,2)    ==> " + gb)
    println("gb.isEmpty                 ==> " + gb.isEmpty)
    println("gb.hasVertex(1)            ==> " + gb.hasVertex(1))
    println("gb.hasVertex(2)            ==> " + gb.hasVertex(2))
    println("gb.hasVertex(3)            ==> " + gb.hasVertex(3))
    println("gb.hasEdge(1,1)            ==> " + gb.hasEdge(1,1))
    println("gb.hasEdge(2,2)            ==> " + gb.hasEdge(2,2))
    println("gb.hasEdge(3,3)            ==> " + gb.hasEdge(3,3))
    println("gb.hasEdge(1,2)            ==> " + gb.hasEdge(1,2))
    println("gb.hasEdge(2,1)            ==> " + gb.hasEdge(2,1))
    println("gb.hasEdge(2,3)            ==> " + gb.hasEdge(2,3))
    println("gb.hasEdge(3,2)            ==> " + gb.hasEdge(3,2))
    println("gb.hasEdge(1,3)            ==> " + gb.hasEdge(1,3))
    println("gb.hasEdge(3,1)            ==> " + gb.hasEdge(3,1))
    println("gb.allVertices             ==> " + gb.allVertices)
    println("gb.allVerticesLabels       ==> " + gb.allVerticesLabels)
    println("gb.fromEdges(1)            ==> " + gb.fromEdges(1))
    println("gb.fromEdges(2)            ==> " + gb.fromEdges(2))
    println("gb.fromEdges(3)            ==> " + gb.fromEdges(3))
    println("gb.fromEdgLabels(1)        ==> " + gb.fromEdgesLabels(1))
    println("gb.fromEdgLabels(2)        ==> " + gb.fromEdgesLabels(2))
    println("gb.fromEdgLabels(3)        ==> " + gb.fromEdgesLabels(3))
    println("\n")

    val gc = gb.addEdge(2,1,2001)
    println("gc = ga.addEdge(2,1,2001)  ==> " + gc)
    println("gc.isEmpty                 ==> " + gc.isEmpty)
    println("gc.hasVertex(1)            ==> " + gc.hasVertex(1))
    println("gc.hasVertex(2)            ==> " + gc.hasVertex(2))
    println("gc.hasVertex(3)            ==> " + gc.hasVertex(3))
    println("gc.hasEdge(1,1)            ==> " + gc.hasEdge(1,1))
    println("gc.hasEdge(2,2)            ==> " + gc.hasEdge(2,2))
    println("gc.hasEdge(3,3)            ==> " + gc.hasEdge(3,3))
    println("gc.hasEdge(1,2)            ==> " + gc.hasEdge(1,2))
    println("gc.hasEdge(2,1)            ==> " + gc.hasEdge(2,1))
    println("gc.hasEdge(2,3)            ==> " + gc.hasEdge(2,3))
    println("gc.hasEdge(3,2)            ==> " + gc.hasEdge(3,2))
    println("gc.hasEdge(1,3)            ==> " + gc.hasEdge(1,3))
    println("gc.hasEdge(3,1)            ==> " + gc.hasEdge(3,1))
    println("gc.allVertices             ==> " + gc.allVertices)
    println("gc.allVerticesLabels       ==> " + gc.allVerticesLabels)
    println("gc.fromEdges(1)            ==> " + gc.fromEdges(1))
    println("gc.fromEdges(2)            ==> " + gc.fromEdges(2))
    println("gc.fromEdges(3)            ==> " + gc.fromEdges(3))
    println("gc.fromEdgLabels(1)        ==> " + gc.fromEdgesLabels(1))
    println("gc.fromEdgLabels(2)        ==> " + gc.fromEdgesLabels(2))
    println("gc.fromEdgLabels(3)        ==> " + gc.fromEdgesLabels(3))
    println("\n")

    val gd = gc.removeVertex(3)
    println("gd = gb.removeVertex(3)    ==> " + gd)
    println("gd.isEmpty                 ==> " + gd.isEmpty)
    println("gd.hasVertex(1)            ==> " + gd.hasVertex(1))
    println("gd.hasVertex(2)            ==> " + gd.hasVertex(2))
    println("gd.hasVertex(3)            ==> " + gd.hasVertex(3))
    println("gd.hasEdge(1,1)            ==> " + gd.hasEdge(1,1))
    println("gd.hasEdge(2,2)            ==> " + gd.hasEdge(2,2))
    println("gd.hasEdge(3,3)            ==> " + gd.hasEdge(3,3))
    println("gd.hasEdge(1,2)            ==> " + gd.hasEdge(1,2))
    println("gd.hasEdge(2,1)            ==> " + gd.hasEdge(2,1))
    println("gd.hasEdge(2,3)            ==> " + gd.hasEdge(2,3))
    println("gd.hasEdge(3,2)            ==> " + gd.hasEdge(3,2))
    println("gd.hasEdge(1,3)            ==> " + gd.hasEdge(1,3))
    println("gd.hasEdge(3,1)            ==> " + gd.hasEdge(3,1))
    println("gd.allVertices             ==> " + gd.allVertices)
    println("gc.allVerticesLabels       ==> " + gd.allVerticesLabels)
    println("gd.fromEdges(1)            ==> " + gd.fromEdges(1))
    println("gd.fromEdges(2)            ==> " + gd.fromEdges(2))
    println("gd.fromEdges(3)            ==> " + gd.fromEdges(3))
    println("gd.fromEdgLabels(1)        ==> " + gd.fromEdgesLabels(1))
    println("gd.fromEdgLabels(2)        ==> " + gd.fromEdgesLabels(2))
    println("gd.fromEdgLabels(3)        ==> " + gd.fromEdgesLabels(3))
    println("\n")

  }

}
