% $Id: UnparseTest.oz,v 1.3 2009/01/10 18:51:41 leavens Exp $
% AUTHOR: Gary T. Leavens
\insert 'Unparse.oz'
\insert 'TestingNoStop.oz' %% from the course library
declare
% A helping procedure to eliminate repitition in the testing below
proc {UPTest Expected AST}
   UPAST = {VirtualString.toString {Unparse AST}}
   StrExpected = {VirtualString.toString Expected}
in
   {System.showInfo UPAST # " == " # StrExpected}
   {Assert UPAST == StrExpected}
end

{UPTest "skip"
 skipStmt
}

{UPTest "local A in skip end"
 localStmt("A" skipStmt)
}

{UPTest "A = B"
 assignStmt("A" varIdExp("B"))
}

{UPTest "A = 3"
 assignStmt("A" numExp(3))
}

{UPTest "A = 3 B = C"
 seqStmt([assignStmt("A" numExp(3)) assignStmt("B" varIdExp("C"))])
}

{UPTest "A = 3 B = C E = A"
 seqStmt([assignStmt("A" numExp(3)) assignStmt("B" varIdExp("C"))
          assignStmt("E" varIdExp("A"))])
}

{UPTest "if B then skip else skip end"
 ifStmt(varIdExp("B") skipStmt skipStmt)
}

{UPTest "if true then R = true else R = false end"
 ifStmt(boolExp(true)
        assignStmt("R" boolExp(true))
        assignStmt("R" boolExp(false)))
}

{UPTest "if 3 then skip else skip end"
 ifStmt(numExp(3) skipStmt skipStmt)
}

{UPTest "if 3 then A = B else skip end"
 ifStmt(numExp(3) assignStmt("A" varIdExp("B")) skipStmt)
}

{UPTest "if X then A = B else skip end"
 ifStmt(varIdExp("X") assignStmt("A" varIdExp("B")) skipStmt)
}

{UPTest "if X then A = B else D = Z end"
 ifStmt(varIdExp("X")
        assignStmt("A" varIdExp("B"))
        assignStmt("D" varIdExp("Z")))
}

{UPTest "local A in A = B end"
 localStmt("A" assignStmt("A" varIdExp("B")))
}

{UPTest "local A in A = 3 end"
 localStmt("A" assignStmt("A" numExp(3)))
}

{UPTest "local A in A = A end"
 localStmt("A" assignStmt("A" varIdExp("A")))
}

{UPTest "local A in B = C end"
 localStmt("A" assignStmt("B" varIdExp("C")))
}

{UPTest "case C of ok then skip else skip end"
 caseStmt(varIdExp("C") atomPat(ok) skipStmt skipStmt)
}

{UPTest "case C of X then skip else skip end"
 caseStmt(varIdExp("C") varIdPat("X") skipStmt skipStmt)
}

{UPTest "case C of X then B = X else skip end"
 caseStmt(varIdExp("C") varIdPat("X")
          assignStmt("B" varIdExp("X"))
          skipStmt)
}

{UPTest "case C of X then B = X else D = 7 end"
 caseStmt(varIdExp("C") varIdPat("X")
          assignStmt("B" varIdExp("X"))
          assignStmt("D" numExp(7)))
}

{UPTest "case C of nowXisFree then B = X else D = 7 end"
 caseStmt(varIdExp("C") atomPat(nowXisFree)
          assignStmt("B" varIdExp("X"))
          assignStmt("D" numExp(7)))
}

{UPTest "case C of Q then B = X else Z = Q end"
 caseStmt(varIdExp("C")
          varIdPat("Q")
          assignStmt("B" varIdExp("X"))
          assignStmt("Z" varIdExp("Q")))
}

{UPTest "case C of foo() then B = X else D = 7 end"
 caseStmt(varIdExp("C") recordPat(foo nil)
          assignStmt("B" varIdExp("X"))
          assignStmt("D" numExp(7)))
}

{UPTest "case C of foo(X Y) then B = X else D = Y end"
 caseStmt(varIdExp("C") recordPat(foo [posFld(varIdExp("X"))
                                       posFld(varIdExp("Y"))])
          assignStmt("B" varIdExp("X"))
          assignStmt("D" varIdExp("Y")))
}

{UPTest "case C of foo(f1:X f2:Y) then B = X else D = Y end"
 caseStmt(varIdExp("C") recordPat(foo [colonFld(f1 varIdExp("X"))
                                       colonFld(f2 varIdExp("Y"))])
          assignStmt("B" varIdExp("X"))
          assignStmt("D" varIdExp("Y")))
}

{UPTest "case C of foo(f1:bar(f2:X f3:Y f4:Z))"
        # " then B = X if Z then D = Y else skip end"
        # " else skip end"
 caseStmt(varIdExp("C")
          recordPat(foo
                    [colonFld(f1
                              recordExp(atomExp(bar)
                                        [colonFld(f2 varIdExp("X"))
                                         colonFld(f3 varIdExp("Y"))
                                         colonFld(f4 varIdExp("Z"))]))])
          seqStmt([assignStmt("B" varIdExp("X"))
                  ifStmt(varIdExp("Z") assignStmt("D" varIdExp("Y")) skipStmt)])
          skipStmt)
}

{UPTest "case C of foo(f1:bar(f2:X f3:Y f4:Q))"
        # " then B = X if Z then D = Y else skip end"
        # " else skip end"
 caseStmt(varIdExp("C")
          recordPat(foo
                    [colonFld(f1
                              recordExp(atomExp(bar)
                                        [colonFld(f2 varIdExp("X"))
                                         colonFld(f3 varIdExp("Y"))
                                         colonFld(f4 varIdExp("Q"))]))])
          seqStmt([assignStmt("B" varIdExp("X"))
                  ifStmt(varIdExp("Z") assignStmt("D" varIdExp("Y")) skipStmt)])
          skipStmt)
}

{UPTest "{P}"
 applyStmt(varIdExp("P") nil)
}

{UPTest "{Browse 3}"
 applyStmt(varIdExp("Browse") [numExp(3)])
}

{UPTest "{Map Ls F}"
 applyStmt(varIdExp("Map") [varIdExp("Ls") varIdExp("F")])
}

{UPTest "{Map 3|nil F}"
 applyStmt(varIdExp("Map")
           [recordExp(atomExp('|') [posFld(numExp(3)) posFld(atomExp(nil))])
            varIdExp("F")])
}

{UPTest "{Map 3|nil proc {$ X R} {Browse X} R = X end}"
 applyStmt(varIdExp("Map")
           [recordExp(atomExp('|') [posFld(numExp(3)) posFld(atomExp(nil))])
            procExp([varIdPat("X") varIdPat("R")]
                    seqStmt([applyStmt(varIdExp("Browse") [varIdExp("X")])
                             assignStmt("R" varIdExp("X"))]))])
}

{UPTest "{Map 3|nil proc {$ X R} {Browse X} R = Y end}"
 applyStmt(varIdExp("Map")
           [recordExp(atomExp('|') [posFld(numExp(3)) posFld(atomExp(nil))])
            procExp([varIdPat("X") varIdPat("R")]
                    seqStmt([applyStmt(varIdExp("Browse") [varIdExp("X")])
                             assignStmt("R" varIdExp("Y"))]))])
}

{UPTest "Three = proc {$ R} R = 3 end"
 assignStmt("Three" procExp([varIdPat("R")] assignStmt("R" numExp(3))))
}

{UPTest "fun {Three} 3 end"
 namedFunStmt("Three" nil numExp(3))
}

{UPTest "fun {Add X Y} {Plus X Y} end"
 namedFunStmt("Add" [varIdPat("X") varIdPat("Y")]
              applyExp(varIdExp("Plus") [varIdExp("X") varIdExp("Y")]))
}

{UPTest "fun {Add X Y} {Plus X X Z} end"
 namedFunStmt("Add" [varIdPat("X") varIdPat("Y")]
              applyExp(varIdExp("Plus") [varIdExp("X") varIdExp("X")
                                         varIdExp("Z")]))
}

{UPTest "fun {F X} proc {$ F R} R = {F A} end end"
 namedFunStmt("F" [varIdPat("X")]
              procExp([varIdPat("F") varIdPat("R")]
                      assignStmt("R" applyExp(varIdExp("F") [varIdExp("A")]))))
}

{UPTest "InTest = proc {$ Tree R} node(X Y) = Tree in R = {Plus X Y} end"
 assignStmt("InTest"
            procExp([varIdPat("Tree") varIdPat("R")]
                    inStmt(recordPat(node
                                     [posFld(varIdExp("X"))
                                      posFld(varIdExp("Y"))])
                           varIdExp("Tree")
                           assignStmt("R"
                                      applyExp(varIdExp("Plus")
                                               [varIdExp("X")
                                                varIdExp("Y")])))))
}

{UPTest "fun {First X#Y} X end"
 namedFunStmt("First" [recordPat('#' [posFld(varIdExp("X"))
                                      posFld(varIdExp("Y"))])]
              varIdExp("X"))
}

{UPTest "fun {RevPair X#Y} Y#X end"
 namedFunStmt("RevPair" [recordPat('#' [posFld(varIdExp("X"))
                                      posFld(varIdExp("Y"))])]
              recordExp(atomExp('#')
                        [posFld(varIdExp("Y")) posFld(varIdExp("X"))]))
}

{UPTest "fun {RevPair P} case P of X#Y then Y#X else error end end"
 namedFunStmt("RevPair" [varIdPat("P")]
              caseExp(varIdExp("P")
                      recordPat('#' [posFld(varIdExp("X"))
                                     posFld(varIdExp("Y"))])
                      recordExp(atomExp('#')
                                [posFld(varIdExp("Y")) posFld(varIdExp("X"))])
                      atomExp(error)))
}

{UPTest "fun {T N} if {Odd N} then {Div {Plus {Mult 3 N} 1} 2}"
                          # " else {Div N 2} end end"
 namedFunStmt("T" [varIdPat("N")]
              ifExp(applyExp(varIdExp("Odd") [varIdExp("N")])
                    applyExp(varIdExp("Div")
                             [applyExp(varIdExp("Plus")
                                       [applyExp(varIdExp("Mult")
                                                 [numExp(3) varIdExp("N")])
                                        numExp(1)])
                              numExp(2)])
                    applyExp(varIdExp("Div") [varIdExp("N") numExp(2)])))
}

declare
ParsedFigExample = % (Figure 2 of homework 3a)
namedFunStmt("AddToEach"
             [recordPat('#'
                        [posFld(varIdExp("A")) posFld(varIdExp("B"))])
              varIdPat("Ls")]
   caseExp(varIdExp("Ls")
           recordPat('|'
                     [posFld(recordExp(atomExp('#')
                                      [posFld(varIdExp("X"))
                                       posFld(varIdExp("Y"))]))
                      posFld(varIdExp("T"))])
           recordExp(atomExp('|')
                     [posFld(recordExp(atomExp('#')
                                       [posFld(applyExp(varIdExp("Plus") 
                                                        [varIdExp("A")
                                                         varIdExp("X")]))
                                        posFld(applyExp(varIdExp("Plus")
                                                        [varIdExp("B")
                                                         varIdExp("Y")]))]))
                      posFld(applyExp(varIdExp("AddToEach")
                                      [recordExp(atomExp('#')
                                                 [posFld(varIdExp("A"))
                                                  posFld(varIdExp("B"))])
                                       varIdExp("T")]))])
           atomExp(nil)))

{UPTest
 "fun {AddToEach A#B Ls}"
 # " case Ls of X#Y|T then {Plus A X}#{Plus B Y}|{AddToEach A#B T}"
 # " else nil end"
 # " end"
 ParsedFigExample
 }