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 mmahringer <s1520454056@students.fh-hagenberg.at>
Thu, 06 Jul 2017 16:00:33 +0200
changeset 5183 a85c7ff660d9
parent 5149 e6c0c12a36b0
child 5191 bcc8361629d7
permissions -rw-r--r--
remove warinings 
     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 

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

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

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

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

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

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

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

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

   133 

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

   135   }

   136 

   137 

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

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

   140      * 

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

   142      * with types dropped in ast and rule.

   143      * 

   144      * assert was too expensive at this moment.

   145      */

   146   def test_list_normal() {

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

   148     

   149     //======= 1.successful application 

   150     //###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"]) 

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

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

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

   154     var ast =

   155       Ast.Appl(List(

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

   157         Ast.Variable("bbb"),

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

   159     var lhs =

   160       Appl(List(

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

   162         Variable("x"),

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

   164     var rhs =

   165       Appl(List(

   166         Constant("_list"),

   167         Variable("x")))

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

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

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

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

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

   173 

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

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

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

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

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

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

   180 

   181     //------- whole ast calling try_rules:

   182     ast =

   183       Ast.Appl(List(

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

   185         Ast.Variable("aaa"),

   186         Ast.Appl(List(

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

   188           Ast.Variable("bbb"),

   189           Ast.Appl(List(

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

   191             Ast.Variable("ccc"),

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

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

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

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

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

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

   198 

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

   200     //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"))))))))

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

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

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

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

   205       Appl(List(

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

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

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

   209             

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

   211        Appl(List(

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   227      */

   228 

   229     ast =

   230       Appl(List(

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

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

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

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

   235     

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

   237   }

   238 

   239   def test_tuple_normal() = {

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

   241     

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

   243     var term_from_Isabelle_Isac =

   244       App(

   245         App(

   246           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"))))))))))))),

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

   248         App(

   249           App(

   250             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"))))))))))),

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

   252           App(

   253             App(

   254               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"))))))))),

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

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

   257           ))

   258         ))

   259     var simple_ast = Syntax_Phases.simple_ast_of(term_from_Isabelle_Isac)

   260     assertEquals(simple_ast,

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

   262         Constant("Product_Type.Pair"),

   263         Variable("aaa"),

   264         Appl(List(

   265           Constant("Product_Type.Pair"),

   266           Variable("bbb"),

   267           Appl(List(

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

   269             Variable("ccc"),

   270             Variable("ddd")))

   271           ))

   272         ))

   273       )

   274     var pre_ast : Ast.Ast = simple_ast

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

   276 //      Appl(List(

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

   278 //        Variable("aaa"),

   279 //        Appl(List(

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

   281 //          Variable("bbb"),

   282 //          Appl(List(

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

   284 //            Appl(List(                     //???^^^^^^^^^^^

   285 //               Variable("ccc"))),

   286 //               Variable("ddd")))))))

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

   288       Appl(List(

   289         Constant("_tuple"),  

   290         Variable("aaa"),

   291         Appl(List(

   292           Constant("_tuple_args"),  

   293           Variable("bbb"),

   294           Appl(List(

   295             Constant("_tuple_args"),

   296             Variable("ccc"),

   297             Appl(List(

   298               Constant("_tuple_arg"),  

   299               Variable("ddd")))))))))

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

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

   302                   

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

   304   }

   305   

   306   def test_matches() = {

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

   308     

   309     // at this ast rule 2 should match

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

   311       Appl(List(

   312         Constant("_tuple"),  

   313         Variable("bbb"),

   314         Appl(List(

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

   316           Appl(List(

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

   318               Variable("ccc"),

   319               Appl(List(

   320                 Constant("_tuple_arg"),  

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

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

   323       Appl(List(

   324         Constant("_tuple"),

   325         Variable("x"),

   326         Appl(List(

   327           Constant("_tuple_arg"),

   328           Appl(List(

   329             Constant("_tuple"),

   330             Variable("y"),

   331             Variable("z"))))))) 

   332     var ast_pat = (ML4_2old_ast, ML4_2lhs)

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

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

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

   336     

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

   338       Appl(List(

   339         Constant("_tuple"),

   340         Variable("aaa"),

   341         Appl(List(

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

   343           Appl(List(

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

   345             Variable("bbb"),

   346             Appl(List(

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

   348               Appl(List(

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

   350                 Variable("ccc"),

   351                 Appl(List(

   352                   Constant("_tuple_arg"),

   353                   Variable("ddd")))))))))))))

   354     ast_pat = (scala4_2old_ast, ML4_2lhs)

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

   356     // 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()))

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

   358 

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

   360   }

   361   

   362       

   363   def test_update() {

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

   365 

   366     val ast =

   367     /*List()*/    Appl(List(

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

   369     /*List(2)*/     Appl(List(

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

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

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

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

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

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

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

   377             

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

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

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

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

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

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

   384     

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

   386         Appl(List(

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

   388          Variable("X"),

   389          Variable("Y"))), ast)))

   390     

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

   392   }

   393 

   394   def test_get_value() {

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

   396     

   397     val ast =

   398     /*List()*/    Appl(List(

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

   400     /*List(2)*/     Appl(List(

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

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

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

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

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

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

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

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

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

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

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

   412     

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

   414   }

   415 

   416   def test_math_string_of_arbitrary() {

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

   418     

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

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

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

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

   423     

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

   425   }

   426 }
wneuper/isac