structure PersistentVectorTests =
struct
  open Railroad
  open Railroad.Test

  fun isNotInRange (lst, pv) =
    let
      fun loopNotInRange lst =
        case lst of
          hd :: tl =>
            if PersistentVector.isInRange (hd, pv) then
              let
                val msg =
                  "idx " ^ Int.toString hd
                  ^ " is in range when it shouldn't be\n"
                val () = print msg
              in
                Expect.isTrue false
              end
            else
              loopNotInRange tl
        | [] => Expect.isTrue true
    in
      loopNotInRange lst
    end

  fun isInRange (lst, pv) =
    let
      fun loopInRange lst =
        case lst of
          hd :: tl =>
            if PersistentVector.isInRange (hd, pv) then
              loopInRange tl
            else
              let
                val msg =
                  "idx " ^ Int.toString hd
                  ^ " is not in range when it should be\n"
                val () = print msg
              in
                Expect.isTrue false
              end
        | [] => Expect.isTrue true
    in
      loopInRange lst
    end

  val appendTests = describe "PersistentVector.append"
    [ test "contains appended values in range" (fn _ =>
        let
          (* arrange *)
          val f = PersistentVector.append
          val pv = PersistentVector.empty

          (* act *)
          val pv = f (1, 3, pv)
          val pv = f (5, 7, pv)
          val pv = f (9, 13, pv)
          val pv = f (19, 27, pv)
          val pv = f (33, 33, pv)

          (* assert *)
          (* we split the list into several smaller lists
          * and then concatenate at the end
          * so that the formatter does not cause
          * each list element to take its own line *)
          val indicesInRange1 = [1, 2, 3, 5, 6, 7, 9]
          val indicesInRange2 = [10, 11, 12, 13, 19, 20]
          val indicesInRange3 = [21, 22, 23, 24, 25, 26, 27, 33]

          val indicesInRange =
            indicesInRange1 @ indicesInRange2 @ indicesInRange3
        in
          isInRange (indicesInRange, pv)
        end)
    , test "does not contain values in range that were not appended" (fn _ =>
        let
          (* arrange *)
          val f = PersistentVector.append
          val pv = PersistentVector.empty
          (* act *)
          val pv = f (1, 3, pv)
          val pv = f (5, 7, pv)
          val pv = f (9, 13, pv)
          val pv = f (19, 27, pv)
          val pv = f (33, 33, pv)

          (* assert *)
          val indicesNotInRange =
            [0, 4, 8, 14, 15, 16, 17, 18, 28, 29, 30, 31, 32, 34, 35]
        in
          isNotInRange (indicesNotInRange, pv)
        end)
    ]

  val toListTests = describe "PersistentVector.toList"
    [ test "returns input list when input list has 5 elements" (fn _ =>
        let
          (* arrange *)
          val inputList =
            [ {start = 1, finish = 3}
            , {start = 5, finish = 7}
            , {start = 9, finish = 13}
            , {start = 19, finish = 27}
            , {start = 33, finish = 33}
            ]
          val pv = PersistentVector.fromList inputList

          (* act *)
          val outputList = PersistentVector.toList pv

        (* assert *)
        in
          Expect.isTrue (inputList = outputList)
        end)
    , test "returns input list when input list has more than 32 elements"
        (fn _ =>
           let
             (* arrange *)
             val inputList =
               [ {start = 1, finish = 1}
               , {start = 2, finish = 2}
               , {start = 3, finish = 3}
               , {start = 4, finish = 4}
               , {start = 5, finish = 5}
               , {start = 6, finish = 6}
               , {start = 7, finish = 7}
               , {start = 8, finish = 8}
               , {start = 9, finish = 9}
               , {start = 10, finish = 10}
               , {start = 11, finish = 11}
               , {start = 12, finish = 12}
               , {start = 13, finish = 13}
               , {start = 14, finish = 14}
               , {start = 15, finish = 15}
               , {start = 16, finish = 16}
               , {start = 17, finish = 17}
               , {start = 18, finish = 18}
               , {start = 19, finish = 19}
               , {start = 20, finish = 20}
               , {start = 21, finish = 21}
               , {start = 22, finish = 22}
               , {start = 23, finish = 23}
               , {start = 24, finish = 24}
               , {start = 25, finish = 25}
               , {start = 26, finish = 26}
               , {start = 27, finish = 27}
               , {start = 28, finish = 28}
               , {start = 29, finish = 29}
               , {start = 30, finish = 30}
               , {start = 31, finish = 31}
               , {start = 32, finish = 32}
               , {start = 33, finish = 33}
               , {start = 34, finish = 34}
               , {start = 35, finish = 35}
               ]
             val pv = PersistentVector.fromList inputList

             (* act *)
             val outputList = PersistentVector.toList pv

           (* assert *)
           in
             Expect.isTrue (inputList = outputList)
           end)
    ]

  val splitLeftTests = describe "PersistentVector.splitLeft"
    [ test
        "returns same vector when split idx is greater than any idx in vector"
        (fn _ =>
           let
             (* arrange *)
             val inputList =
               [ {start = 1, finish = 1}
               , {start = 2, finish = 2}
               , {start = 3, finish = 3}
               , {start = 4, finish = 4}
               , {start = 5, finish = 5}
               , {start = 6, finish = 6}
               , {start = 7, finish = 7}
               , {start = 8, finish = 8}
               ]
             val pv = PersistentVector.fromList inputList

             (* act *)
             val pv = PersistentVector.splitLeft (9, pv)

             (* assert *)
             val outputList = PersistentVector.toList pv
           in
             Expect.isTrue (inputList = outputList)
           end)
    , test "removes last element when split idx is = to last element" (fn _ =>
        let
          (* arrange *)
          val inputList =
            [ {start = 1, finish = 1}
            , {start = 2, finish = 2}
            , {start = 3, finish = 3}
            , {start = 4, finish = 4}
            , {start = 5, finish = 5}
            , {start = 6, finish = 6}
            , {start = 7, finish = 7}
            , {start = 8, finish = 8}
            ]
          val pv = PersistentVector.fromList inputList

          (* act *)
          val pv = PersistentVector.splitLeft (8, pv)

          (* assert *)
          val outputList = PersistentVector.toList pv
          val expectedOutput =
            [ {start = 1, finish = 1}
            , {start = 2, finish = 2}
            , {start = 3, finish = 3}
            , {start = 4, finish = 4}
            , {start = 5, finish = 5}
            , {start = 6, finish = 6}
            , {start = 7, finish = 7}
            ]
        in
          Expect.isTrue (outputList = expectedOutput)
        end)
    , test "removes all elements when split idx = first element" (fn _ =>
        let
          (* arrange *)
          val inputList =
            [ {start = 1, finish = 1}
            , {start = 2, finish = 2}
            , {start = 3, finish = 3}
            , {start = 4, finish = 4}
            , {start = 5, finish = 5}
            , {start = 6, finish = 6}
            , {start = 7, finish = 7}
            , {start = 8, finish = 8}
            ]
          val pv = PersistentVector.fromList inputList

          (* act *)
          val pv = PersistentVector.splitLeft (1, pv)

          (* assert *)
          val outputList = PersistentVector.toList pv
          val expectedOutput = []
        in
          Expect.isTrue (outputList = expectedOutput)
        end)
    , test
        "removes element whose start and finish is in range \
        \of the split idx, and removes all elements after it too"
        (fn _ =>
           let
             (* arrange *)
             val inputList =
               [ {start = 1, finish = 1}
               , {start = 2, finish = 2}
               , {start = 3, finish = 3}
               , {start = 4, finish = 4}
               , {start = 5, finish = 155}
               , {start = 200, finish = 200}
               , {start = 210, finish = 210}
               , {start = 220, finish = 220}
               , {start = 230, finish = 230}
               , {start = 240, finish = 240}
               , {start = 250, finish = 250}
               ]
             val pv = PersistentVector.fromList inputList

             (* act *)
             val pv = PersistentVector.splitLeft (7, pv)

             (* assert *)
             val outputList = PersistentVector.toList pv
             val expectedOutput =
               [ {start = 1, finish = 1}
               , {start = 2, finish = 2}
               , {start = 3, finish = 3}
               , {start = 4, finish = 4}
               ]
           in
             Expect.isTrue (outputList = expectedOutput)
           end)
    ]

  val deleteTests = describe "PersistentVector.delete"
    [test
       "returns the left side of the vector \
       \when 'finish' is greater than any element in the vector"
       (fn _ =>
          let
            (* arrange *)
            val inputList =
              [ {start = 1, finish = 1}
              , {start = 2, finish = 2}
              , {start = 3, finish = 3}
              , {start = 4, finish = 4}
              , {start = 5, finish = 5}
              , {start = 6, finish = 6}
              , {start = 7, finish = 7}
              , {start = 8, finish = 8}
              ]
            val pv = PersistentVector.fromList inputList

            (* act *)
            val pv = PersistentVector.delete (5, 9, pv)

            (* assert *)
            val outputList = PersistentVector.toList pv
            val expectedOutput =
              [ {start = 1, finish = 1}
              , {start = 2, finish = 2}
              , {start = 3, finish = 3}
              , {start = 4, finish = 4}
              ]
          in
            Expect.isTrue (outputList = expectedOutput)
          end)]

  val tests = [appendTests, toListTests, splitLeftTests, deleteTests]
end