Mercurial Mercurial > wneuper > isac / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
isac-java/src/java-tests/isac/gui/mawen/syntax/TestAst.scala
author Walther Neuper <walther.neuper@jku.at>
Fri, 26 Mar 2021 10:45:05 +0100
changeset 5239 b4e3883d7b66
parent 5229 6bf0e95981e3
permissions -rw-r--r--
reset mathematics-engine to Isabelle2015

note: for this version libisabelle was available,
which connects front-end (Java) and back-end (Isabelle/ML) 
     1 package isac.gui.mawen.syntax

     2 

     3 import isac.gui.mawen.scalaterm.TestsDATA

     4 import isac.gui.mawen.TestDATA

     5 import isac.gui.mawen.syntax.Ast._  //"._" simplifies "Ast.Ast" to "Ast"

     6 import edu.tum.cs.isabelle.pure._   // for Term

     7 import isac.gui.mawen.syntax.isabelle.XLibrary

     8 import isac.gui.mawen.editor.TestDATAeditor

     9 

    10 import junit.framework.TestCase

    11 import org.junit.Assert._

    12 

    13 

    14 class TestAst extends TestCase {

    15 

    16   // x / y

    17   def a1 = Appl(List(Constant("Fields.inverse_class.divide"), Variable ("x"), Variable ("y")))

    18   // a * b / c

    19   def a2 = Appl(List(Constant("Groups.times_class.times"), Variable ("a"), Appl(List(Constant("Fields.inverse_class.divide"), Variable("b"), Variable("c")))))

    20   // sin(a + b) / c

    21   def a3 = Appl(List

    22       (Constant("Fields.inverse_class.divide"), 

    23           Appl(List(Constant("sin"), 

    24               Appl(List(Constant("Groups.plus_class.plus"), 

    25                   Variable("a"), 

    26                   Variable("b")

    27               ))

    28           ))

    29           ,Variable ("c")

    30       ))

    31   def a4 = Appl(List(Constant("Groups.plus_class.plus"), Appl(List(Constant("Groups.plus_class.plus"), Variable("a"), Variable("b"))), Variable("c")))

    32   def a5 = Appl(List(Constant("Groups.plus_class.plus"), Variable("a"), Appl(List(Constant("Groups.plus_class.plus"), Variable("b"), Variable("c")))))

    33   var post_ast : Ast.Ast = //copied from Isabelle2016-1-MAWEN, types dropped

    34     Appl(List(

    35       Constant("_tuple"),  

    36       Variable("aaa"),

    37       Appl(List(

    38         Constant("_tuple_args"),  

    39         Variable("bbb"),

    40         Appl(List(

    41           Constant("_tuple_args"),

    42           Variable("ccc"),

    43           Appl(List(

    44             Constant("_tuple_arg"),  

    45             Variable("ddd")))))))))

    46   

    47   def test_prefix_string_of() {

    48     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_prefix_string_of");

    49     

    50     assertEquals(Ast.prefix_string_of(a1), "/ x y")

    51     assertEquals(Ast.prefix_string_of(a2), "* a / b c")

    52     assertEquals(Ast.prefix_string_of(a3), "/ sin + a b c")

    53     

    54     println("\\--END isac.gui.mawen.asttrans.TestAst#test_prefix_string_of");

    55   }

    56   

    57   def test_math_string_of() {

    58     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_math_string_of");

    59     

    60     assertEquals(Ast.math_string_of(a1), "x / y")

    61     assertEquals(Ast.math_string_of(a2), "a * (b / c)")

    62     assertEquals(Ast.math_string_of(a3), "sin (a + b) / c")

    63 

    64     assertEquals(Ast.math_string_of(a4), "a + b + c")

    65     assertEquals(Ast.math_string_of(a5), "a + (b + c)")

    66     assertEquals(Ast.math_string_of(post_ast), "(aaa, bbb, ccc, ddd)")

    67     

    68     println("\\--END isac.gui.mawen.asttrans.TestAst#test_math_string_of");

    69   }

    70   

    71   /* 

    72    * The examples for reference of Natalie Karl initially took terms,

    73    * @see isac.gui.mawen.scalaterm.TestUtil.

    74    * Here we check, whether term_to_ast + Ast.string_of give the same result.

    75    */

    76   def test_examples_for_NK() {

    77     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_examples_for_NK");

    78 

    79     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t1)),

    80         "aaa + bbb = processed_by_Isabelle_Isac ")

    81     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t2)), 

    82         "a + 2 * b + 3 * (c + d)")

    83 

    84     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t31)), 

    85         "aaa + bbb + ccc")

    86     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t32)), 

    87         "aaa + (bbb + ccc)")

    88 

    89     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t41)), 

    90         "Diff (x + sin (x ^ 2), x)")

    91     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.t42)), 

    92         "d_d x (x + sin (x ^ 2))")

    93 

    94     // MAWEN example for reference No.1

    95     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.tt1())), 

    96         "Simplify (1 + 2 * x * (y + 3) / (4 * z * (y + 3)) + 5)")

    97     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.tt3())), 

    98         "1 + 2 * x * (y + 3) / (4 * z * (y + 3)) + 5")

    99     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.tt4())), 

   100         "1 + 2 * x / (4 * z) + 5")

   101     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.tt5())), 

   102         "1 + x / (2 * z) + 5")

   103     assertEquals(Ast.math_string_of(Syntax_Phases.term_to_ast(TestsDATA.tt6())), 

   104         "6 + x / (2 * z)")

   105 

   106     println("\\--END isac.gui.mawen.asttrans.TestAst#test_examples_for_NK");

   107   }

   108 

   109   //test additional examples with BOX, CURSOR, GAP

   110   def test_BOX_CURSOR_GAP() {

   111     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_BOX_CURSOR_GAP");

   112 

   113     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_1))   

   114     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_2))   

   115     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_3))

   116 

   117     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_1_CURSOR))   

   118     assertEquals(  "# + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_1_CURSOR_GAP))

   119     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_BOX_1_CURSOR_b))

   120 

   121     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_CURSOR_BOX_3A))   

   122     assertEquals("aaa + bbb", Ast.math_string_of(TestDATAeditor.nest_CURSOR_BOX_3B))

   123     

   124     assertEquals("d_d x x + d_d x (sin (x ^ 2))", Ast.math_string_of(TestDATAeditor.box_05))

   125     assertEquals("d_d bdv (sin (u)) = cos (u) * d_d bdv (u)", Ast.math_string_of(TestDATAeditor.box_06))   

   126     assertEquals("d_d x x + cos (x ^ 2) * d_d x (#)", Ast.math_string_of(TestDATAeditor.box_07_with_cursor))   

   127     assertEquals("a + (# + c)", Ast.math_string_of(TestDATAeditor.box_gap_cursor))   

   128     assertEquals("#", Ast.math_string_of(TestDATAeditor.box_with_cursor_on_gap))   

   129     assertEquals("# + #", Ast.math_string_of(TestDATAeditor.in_1a))   

   130     assertEquals("a + # / #", Ast.math_string_of(TestDATAeditor.in_1b))   

   131     assertEquals("a + b / #", Ast.math_string_of(TestDATAeditor.in_1c))   

   132 

   133     println("\\--END isac.gui.mawen.asttrans.TestAst#test_BOX_CURSOR_GAP");

   134   }

   135 

   136 

   137     /* from Isabelle2016-1-MAWEN ast.ML: 

   138      * fun try_rules ((lhs, rhs) :: pats) ast = (*WN*)

   139      * 

   140      * lemma "[aaa,bbb] = ddd" --- term_to_ast ---

   141      * with types dropped in ast and rule.

   142      * 

   143      * assert was too expensive at this moment.

   144      */

   145   def test_list_normal() {

   146     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_list_normal");

   147     

   148     //======= 1.successful application 

   149     //###try_rules ast: Appl[Constant("List.list.Cons"), Appl[Constant("_constrain"), Appl[Constant("_free"), Variable("bbb"]), Appl[Constant("_ofsort"), Appl[Constant("_tfree"), Variable("'a"]), Constant("\ <^class>HOL.type"]]), Constant("List.list.Nil"]) 

   150     //###try_rules lhs: Appl[Constant("List.list.Cons"), Variable("x"), Constant("List.list.Nil"]) 

   151     //###try_rules rhs: Appl[Constant("_list"), Variable("x"]) 

   152     //------- ast in try_rules (from additional output):

   153     var ast =

   154       Ast.Appl(List(

   155         Ast.Constant("List.list.Cons"),

   156         Ast.Variable("bbb"),

   157         Ast.Constant("List.list.Nil")))

   158     var lhs =

   159       Appl(List(

   160         Constant("List.list.Cons"),

   161         Variable("x"),

   162         Constant("List.list.Nil")))

   163     var rhs =

   164       Appl(List(

   165         Constant("_list"),

   166         Variable("x")))

   167     assertEquals(Ast.matches(ast, lhs), Some((Map("x" -> Variable("bbb")),List())))

   168     // //--------------- tests BEFORE made local to normalize ---------------\\

   169     //assertEquals(Ast.xtry(ast, "List.list.Cons"), Some(Appl(List(Constant("_list"), Variable("bbb")))))

   170     //assertEquals(Ast.try_rules(XSyntax.print_rules("List.list.Cons"), ast), Some(Appl(List(Constant("_list"), Variable("bbb")))))

   171     //assertEquals(Ast.try_rules(List((lhs, rhs)), ast), Some(Appl(List(Constant("_list"), Variable("bbb")))))

   172 

   173     //assertEquals(Ast.rewrite(ast), Some(Appl(List(Constant("_list"), Variable("bbb")))))

   174     //assertEquals(Ast.norm_root(ast), Appl(List(Constant("_list"), Variable("bbb"))))

   175     //assertEquals(Ast.norm(ast),      Appl(List(Constant("_list"), Variable("bbb"))))

   176     //assertEquals(Ast.normal(ast),    Appl(List(Constant("_list"), Variable("bbb"))))

   177     // \\--------------- tests BEFORE made local to normalize ---------------//

   178     assertEquals(Ast.normalize(XSyntax.print_rules, ast), Appl(List(Constant("_list"), Variable("bbb"))))

   179 

   180     //------- whole ast calling try_rules:

   181     ast =

   182       Ast.Appl(List(

   183         Ast.Constant("List.list.Cons"),

   184         Ast.Variable("aaa"),

   185         Ast.Appl(List(

   186           Ast.Constant("List.list.Cons"),

   187           Ast.Variable("bbb"),

   188           Ast.Appl(List(

   189             Ast.Constant("List.list.Cons"),

   190             Ast.Variable("ccc"),

   191             Ast.Constant("List.list.Nil")))))))            

   192     assertEquals(Ast.matches(ast, lhs), None) //--> None: the rewriter calls try_rules!

   193     // //--------------- tests BEFORE made local to normalize ---------------\\

   194     //assertEquals(Ast.xtry(ast, "List.list.Cons"), None)

   195     //assertEquals(Ast.try_rules(XSyntax.print_rules("List.list.Cons"), ast), None)

   196     //assertEquals(Ast.try_rules(List((lhs, rhs)), ast), None)

   197 

   198     //assertEquals(Ast.rewrite(ast), None)

   199     //assertEquals(Ast.norm_root(ast), Appl(List(Constant("List.list.Cons"), Variable("aaa"), Appl(List(Constant("List.list.Cons"), Variable("bbb"), Appl(List(Constant("List.list.Cons"), Variable("ccc"), Constant("List.list.Nil"))))))))

   200     //assertEquals(Ast.normal(ast),    Appl(List(Constant("_list"), Appl(List(Constant("_args"), Variable("aaa"), Appl(List(Constant("_args"), Variable("bbb"), Variable("ccc"))))))))

   201     //assertEquals(Ast.normal(ast),    Appl(List(Constant("_list"), Appl(List(Constant("_args"), Variable("aaa"), Appl(List(Constant("_args"), Variable("bbb"), Variable("ccc"))))))))

   202     // \\--------------- tests BEFORE made local to normalize ---------------//

   203     assertEquals(Ast.normalize(XSyntax.print_rules, ast),

   204       Appl(List(

   205         Constant("_list"), Appl(List(

   206           Constant("_args"), Variable("aaa"), Appl(List(

   207             Constant("_args"), Variable("bbb"), Variable("ccc"))))))))

   208             

   209     /* output from Isabelle_Isac adds types to above structure:

   210        Appl(List(

   211 /*_list*/Constant("_list"), Appl(List(

   212 /*_args*/  Constant("_args"), Appl(List(

   213              Constant("_constrain"), Appl(List(

   214 /* aaa */      Constant("_free"), Variable("aaa"))), Appl(List(

   215                  Constant("_ofsort"), Appl(List(

   216                    Constant("_tfree"), Variable("'a"))), Constant("\\<^class>HOL.type"))))), Appl(List(

   217 /*_args*/            Constant("_args"), Appl(List(

   218                        Constant("_constrain"), Appl(List(

   219 /* bbb */                Constant("_free"), Variable("bbb"))), Appl(List(

   220                            Constant("_ofsort"), Appl(List(

   221                              Constant("_tfree"), Variable("'a"))), Constant("\\<^class>HOL.type"))))), Appl(List(

   222                                Constant("_constrain"), Appl(List(

   223 /* ccc */                        Constant("_free"), Variable("ccc"))), Appl(List(

   224                                    Constant("_ofsort"), Appl(List(

   225                                      Constant("_tfree"), Variable("'a"))), Constant("\\<^class>HOL.type")))))))))))

   226      */

   227 

   228     ast =

   229       Appl(List(

   230         Constant("_list"), Appl(List(

   231           Constant("_args"), Variable("aaa"), Appl(List(

   232             Constant("_args"), Variable("bbb"), Variable("ccc")))))))    

   233     assertEquals("[aaa, bbb, ccc]", Ast.math_string_of(ast))

   234     

   235     println("\\--END isac.gui.mawen.asttrans.TestAst#test_list_normal");

   236   }

   237 

   238   def test_tuple_normal() = {

   239     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_tuple_normal");

   240     

   241     // cp from ScalaTermFromString#test_etc, term_str = "(aaa, bbb, ccc, ddd)"

   242     var term_from_Isabelle_Isac =

   243       App(

   244         App(

   245           Const("Product_Type.Pair", Type("fun", List(TFree("'a", List("HOL.type")),Type("fun", List(Type("Product_Type.prod", List(TFree("'b", List("HOL.type")),Type("Product_Type.prod", List(TFree("'c", List("HOL.type")),TFree("'d", List("HOL.type")))))),Type("Product_Type.prod", List(TFree("'a", List("HOL.type")),Type("Product_Type.prod", List(TFree("'b", List("HOL.type")),Type("Product_Type.prod", List(TFree("'c", List("HOL.type")),TFree("'d", List("HOL.type"))))))))))))),

   246           Free("aaa", TFree("'a", List("HOL.type")))),

   247         App(

   248           App(

   249             Const("Product_Type.Pair", Type("fun", List(TFree("'b", List("HOL.type")),Type("fun", List(Type("Product_Type.prod", List(TFree("'c", List("HOL.type")),TFree("'d", List("HOL.type")))),Type("Product_Type.prod", List(TFree("'b", List("HOL.type")),Type("Product_Type.prod", List(TFree("'c", List("HOL.type")),TFree("'d", List("HOL.type"))))))))))),

   250             Free("bbb", TFree("'b", List("HOL.type")))),

   251           App(

   252             App(

   253               Const("Product_Type.Pair", Type("fun", List(TFree("'c", List("HOL.type")),Type("fun", List(TFree("'d", List("HOL.type")),Type("Product_Type.prod", List(TFree("'c", List("HOL.type")),TFree("'d", List("HOL.type"))))))))),

   254               Free("ccc", TFree("'c", List("HOL.type")))),

   255             Free("ddd", TFree("'d", List("HOL.type"))

   256           ))

   257         ))

   258     var simple_ast = Syntax_Phases.simple_ast_of(term_from_Isabelle_Isac)

   259     assertEquals(simple_ast,

   260       Appl(List(  //println(raw_string_of(simple_ast))

   261         Constant("Product_Type.Pair"),

   262         Variable("aaa"),

   263         Appl(List(

   264           Constant("Product_Type.Pair"),

   265           Variable("bbb"),

   266           Appl(List(

   267             Constant("Product_Type.Pair"), //???vvvvvvvvvvvvv

   268             Variable("ccc"),

   269             Variable("ddd")))

   270           ))

   271         ))

   272       )

   273     var pre_ast : Ast.Ast = simple_ast

   274 //    pre_ast : Ast.Ast =  //copied from Isabelle2016-1-MAWEN, types dropped MAY

   275 //      Appl(List(

   276 //        Constant("Product_Type.Pair"),

   277 //        Variable("aaa"),

   278 //        Appl(List(

   279 //          Constant("Product_Type.Pair"),

   280 //          Variable("bbb"),

   281 //          Appl(List(

   282 //            Constant("Product_Type.Pair"),

   283 //            Appl(List(                     //???^^^^^^^^^^^

   284 //               Variable("ccc"))),

   285 //               Variable("ddd")))))))

   286     var post_ast : Ast.Ast = //copied from Isabelle2016-1-MAWEN, types dropped

   287       Appl(List(

   288         Constant("_tuple"),  

   289         Variable("aaa"),

   290         Appl(List(

   291           Constant("_tuple_args"),  

   292           Variable("bbb"),

   293           Appl(List(

   294             Constant("_tuple_args"),

   295             Variable("ccc"),

   296             Appl(List(

   297               Constant("_tuple_arg"),  

   298               Variable("ddd")))))))))

   299     val ast = normalize(XSyntax.print_rules, pre_ast)

   300     assertEquals(ast, post_ast)        // LETZTES "_tuple_args" <> "_tuple_args"

   301                   

   302     println("\\--END isac.gui.mawen.asttrans.TestAst#test_tuple_normal");

   303   }

   304   

   305   def test_matches() = {

   306     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_matches");

   307     

   308     // at this ast rule 2 should match

   309     val ML4_2old_ast = //AFTER rewrite 3, rule 2, from ###ML old_ast

   310       Appl(List(

   311         Constant("_tuple"),  

   312         Variable("bbb"),

   313         Appl(List(

   314           Constant("_tuple_arg"),   //<---vv

   315           Appl(List(

   316             Constant("_tuple"),     //<---^^

   317               Variable("ccc"),

   318               Appl(List(

   319                 Constant("_tuple_arg"),  

   320                 Variable("ddd")))  ))))))   //->

   321     val ML4_2lhs = //AFTER rewrite 3, rule 2, from ###ML try_rules lhs:

   322       Appl(List(

   323         Constant("_tuple"),

   324         Variable("x"),

   325         Appl(List(

   326           Constant("_tuple_arg"),

   327           Appl(List(

   328             Constant("_tuple"),

   329             Variable("y"),

   330             Variable("z"))))))) 

   331     var ast_pat = (ML4_2old_ast, ML4_2lhs)

   332     // println("matches(ast_pat): " + matches(ast_pat))

   333     // matches(ast_pat): Some((Map(x -> Variable(bbb), y -> Variable(ccc), z -> Appl(List(Constant(_tuple_arg), Variable(ddd)))),List()))

   334     assertTrue((!(matches(ast_pat)).isEmpty))

   335     

   336     val scala4_2old_ast = //AFTER rewrite 3, NO rule 1, from ###post.scala:

   337       Appl(List(

   338         Constant("_tuple"),

   339         Variable("aaa"),

   340         Appl(List(

   341           Constant("_tuple_arg"),   //<---vv pattern from ###ML 4. rule 2 NOT RECOGNISED

   342           Appl(List(

   343             Constant("_tuple"),     //<---^^ pattern from ###ML 4. rule 2 NOT RECOGNISED

   344             Variable("bbb"),

   345             Appl(List(

   346               Constant("_tuple_arg"),     //<---vv pattern from ###ML 4. rule 2 NOT RECOGNISED

   347               Appl(List(

   348                 Constant("_tuple"),       //<---^^ pattern from ###ML 4. rule 2 NOT RECOGNISED

   349                 Variable("ccc"),

   350                 Appl(List(

   351                   Constant("_tuple_arg"),

   352                   Variable("ddd")))))))))))))

   353     ast_pat = (scala4_2old_ast, ML4_2lhs)

   354     // println("matches(ast_pat): " + matches(ast_pat))

   355     // matches(ast_pat): Some((Map(x -> Variable(aaa), y -> Variable(bbb), z -> Appl(List(Constant(_tuple_arg), Appl(List(Constant(_tuple), Variable(ccc), Appl(List(Constant(_tuple_arg), Variable(ddd)))))))),List()))

   356     assertTrue((!(matches(ast_pat)).isEmpty))

   357 

   358     println("\\--END isac.gui.mawen.asttrans.TestAst#test_matches");

   359   }

   360   

   361       

   362   def test_update() {

   363     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_update");

   364 

   365     val ast =

   366     /*List()*/    Appl(List(

   367     /*List(1)*/     Constant("Groups.plus_class.plus"),

   368     /*List(2)*/     Appl(List(

   369     /*List(2,1)*/     Constant("Groups.plus_class.plus"),

   370     /*List(2,2)*/     Variable("a"),

   371     /*List(2,3)*/     Appl(List(

   372     /*List(2,3,1)*/     Constant("Groups.plus_class.plus"),

   373     /*List(2,3,2)*/     Variable("b"),

   374     /*List(2,3,3)*/     Variable("c"))) )),

   375     /*List(3)*/     Variable("d")))

   376             

   377     assertEquals("a + (b + c) + d", math_string_of(ast))

   378     assertEquals("X  + d", math_string_of(add(List(2), Constant("X"), ast)))

   379     assertEquals("X  + (b + c) + d", math_string_of(add(List(2,2), Constant("X"), ast)))

   380     assertEquals("a + (X  + c) + d", math_string_of(add(List(2,3,2), Constant("X"), ast)))

   381     assertEquals("a + (b + X ) + d", math_string_of(add(List(2,3,3), Constant("X"), ast)))

   382     assertEquals("a + (b + c) + X ", math_string_of(add(List(3), Constant("X"), ast)))

   383     

   384     assertEquals("X + Y + d", math_string_of(add(List(2),

   385         Appl(List(

   386          Constant("Groups.plus_class.plus"),

   387          Variable("X"),

   388          Variable("Y"))), ast)))

   389     

   390     println("\\--END isac.gui.mawen.asttrans.TestAst#test_update");

   391   }

   392 

   393   def test_get_value() {

   394     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_get_value");

   395     

   396     val ast =

   397     /*List()*/    Appl(List(

   398     /*List(1)*/     Constant("Groups.plus_class.plus"),

   399     /*List(2)*/     Appl(List(

   400     /*List(2,1)*/     Constant("Groups.plus_class.plus"),

   401     /*List(2,2)*/     Variable("a"),

   402     /*List(2,3)*/     Appl(List(

   403     /*List(2,3,1)*/     Constant("Groups.plus_class.plus"),

   404     /*List(2,3,2)*/     Variable("b"),

   405     /*List(2,3,3)*/     Variable("c"))) )),

   406     /*List(3)*/     Variable("d")))

   407     assertEquals("a + (b + c) + d", math_string_of(get_value (List(), ast)))

   408     assertEquals("a", math_string_of(get_value (List(2,2), ast)))

   409     assertEquals("b + c", math_string_of(get_value (List(2,3), ast)))

   410     assertEquals("b", math_string_of(get_value (List(2,3,2), ast)))

   411     

   412     println("\\--END isac.gui.mawen.asttrans.TestAst#test_get_value");

   413   }

   414 

   415   def test_math_string_of_arbitrary() {

   416     println("/--BEGIN isac.gui.mawen.asttrans.TestAst#test_math_string_of_arbitrary");

   417     

   418     val arbitrary = Appl(List(Variable("a"), Constant("b"),

   419       Appl(List(Constant("Groups.plus_class.plus"), Variable("c"),Variable("d"))),

   420       Appl(List(Variable("y"),Variable("x"))) ))

   421     assertEquals("a b  (c + d) (y (x))", math_string_of(arbitrary))

   422     

   423     println("\\--END isac.gui.mawen.asttrans.TestAst#test_math_string_of_arbitrary");

   424   }

   425 }
wneuper/isac