| modeltype ECORE uses 'http://www.eclipse.org/emf/2002/Ecore'; |
| transformation test(out output: ECORE); |
| |
| constructor EClass::EClass() |
| { |
| } |
| |
| property outProp :EClass = new EClass(); |
| property outProp2 :EClass = new EClass(); |
| |
| main() { |
| // --------- out: null, abstract |
| var contTest1 = new EClass(); |
| var outTest1 :EClassifier = null; |
| var resTest1 = contTest1.map m1(outTest1, "1: "); |
| assert fatal (contTest1.name = "1: self_name"); |
| assert fatal (outTest1.name = "1: out_name"); |
| assert fatal (resTest1.name = "1: result_name"); |
| |
| // --------- out: non-null |
| var outTest2 :EClass = new EClass(); |
| var resTest2 = contTest1.map m2(outTest2, "2: "); |
| assert fatal (contTest1.name = "2: self_name / 1: self_name"); |
| assert fatal (outTest2.name = "2: out_name / 1: self_name"); |
| assert fatal (resTest2.name = "2: result_name"); |
| |
| // --------- same context and out object, different prefix (String) |
| var resTest2a = contTest1.map m2(outTest2, "3: "); |
| assert fatal (contTest1.name = "3: self_name / 2: self_name / 1: self_name"); |
| assert fatal (outTest2.name = "3: out_name / 2: self_name / 1: self_name"); |
| assert fatal (resTest2a.name = "3: result_name"); |
| |
| // --------- same context and prefix, different out object => getting trace value |
| var outTest3 :EClass = new EClass(); |
| var resTest3 = contTest1.map m2(outTest3, "3: "); |
| assert fatal (contTest1.name = "3: self_name / 2: self_name / 1: self_name"); |
| assert fatal (outTest3.name = "3: out_name / 2: self_name / 1: self_name"); |
| assert fatal (resTest3.name = "3: result_name"); |
| |
| // --------- out: List(String) |
| var outTest4: List(String); |
| var resTest4 = contTest1.map m3(outTest4, "4: "); |
| assert fatal (outTest4->includes("4: out_name / 3: self_name / 2: self_name / 1: self_name")); |
| |
| var outTest4a: List(String); |
| var resTest4a = contTest1.map m3(outTest4a, "4: "); |
| assert fatal (outTest4a->includes("4: out_name / 3: self_name / 2: self_name / 1: self_name")); |
| |
| // --------- out: Bag(String) |
| var contTest5 = new EClass(); |
| contTest5.name := ""; |
| var outTest5: Bag(String); |
| var resTest5 = contTest5.map m4(outTest5, "5: "); |
| assert fatal (outTest5->includes("5: out_name / ")); |
| |
| var outTest5a: Bag(String); |
| var resTest5a = contTest5.map m4(outTest5a, "5: "); |
| assert fatal (outTest5a->includes("5: out_name / ")); |
| |
| // ---------- disjuncts |
| var selfTest6 = new EClass(); |
| var outTest6 : EClass; |
| |
| selfTest6.name := "name1"; |
| var resTest6 = map md1(selfTest6, outTest6); |
| assert fatal (outTest6.name = "out2 name1"); |
| |
| selfTest6.name := "name2"; |
| var resTest6a = map md1(selfTest6, outTest6); |
| assert fatal (outTest6.name = "out2 name1"); |
| |
| // ----------- out : property |
| var trans = new test(output); |
| var contTest7 = new EClass(); |
| contTest7.name := "test7"; |
| var resTest7 = contTest7.map m2(trans.outProp, "7: "); |
| assert fatal (trans.outProp.name = "7: out_name / test7"); |
| assert fatal (resTest7.name = "7: result_name"); |
| |
| // --------- same context and prefix, different out object => getting trace value |
| var resTest7a = contTest7.map m2(trans.outProp2, "7: "); |
| assert fatal (trans.outProp2.name = "7: out_name / test7"); |
| assert fatal (resTest7.name = "7: result_name"); |
| |
| // ---------- use of 'inherits' |
| var contTest8 = new EClass(); |
| contTest8.name := "test8 "; |
| var outTest8 : EClass = new EClass(); |
| outTest8.name := "can't read this"; |
| var resTest8 = contTest8.map mi2(outTest8, "8: "); |
| assert fatal (contTest8.name = "8: test8 mi2 self mi1"); |
| assert fatal (outTest8.name = "8: mi2 out mi1"); |
| assert fatal (resTest8.name = "8: result_name"); |
| |
| // --------- same context and prefix, different out object => getting trace value |
| var outTest8a :EClass = new EClass(); |
| var resTest8a = contTest8.map mi2(outTest8a, "8: "); |
| assert fatal (contTest8.name = "8: test8 mi2 self mi1"); |
| assert fatal (outTest8a.name = "8: mi2 out mi1"); |
| assert fatal (resTest8a.name = "8: result_name"); |
| |
| var outTest8b :EClassifier; |
| var resTest8b = contTest8.map mi1(outTest8b, "8: "); |
| assert fatal (contTest8.name = "8: test8 mi2 self mi1"); |
| assert fatal (outTest8b.name = "8: mi2 out mi1"); |
| assert fatal (resTest8b.name = "8: result_name"); |
| |
| // ---------- use of 'merges' |
| var contTest9 = new EClass(); |
| contTest9.name := "test9 "; |
| var outTest9 : EClass = new EClass(); |
| outTest9.name := "can't read this"; |
| var resTest9 = contTest9.map mm2(outTest9, "9: "); |
| assert fatal (contTest9.name = "9: test9 9: mm2 self mm1"); |
| assert fatal (outTest9.name = "9: mm2 out mm1"); |
| assert fatal (resTest9.name = "result_name"); |
| |
| // --------- same context and prefix, different out object => getting trace value |
| var outTest9a :EClass = new EClass(); |
| var resTest9a = contTest9.map mm2(outTest9a, "9: "); |
| assert fatal (contTest9.name = "9: test9 9: mm2 self mm1"); |
| assert fatal (outTest9a.name = "9: mm2 out mm1"); |
| assert fatal (resTest9a.name = "result_name"); |
| |
| var outTest9b :EClassifier; |
| var resTest9b = contTest9.map mm1(outTest9b, "9: "); |
| assert fatal (contTest9.name = "9: test9 9: mm2 self mm1"); |
| assert fatal (outTest9b.name = "9: mm2 out mm1"); |
| assert fatal (resTest9b.name = "result_name"); |
| |
| // ---------- use of nested 'merges' |
| var contTest10 = new EClass(); |
| contTest10.name := "test10 "; |
| var outTest10 : EClass = new EClass(); |
| outTest10.name := "can't read this"; |
| var resTest10 = contTest10.map mmnested3(outTest10, "10: "); |
| assert fatal (contTest10.name = "10: 10: test10 10: 10: mm3 self mm1"); |
| assert fatal (outTest10.name = "10: 10: mm3 out mm1"); |
| assert fatal (resTest10.name = "result_name"); |
| |
| // --------- same context and prefix, different out object => getting trace value |
| var outTest10a :EClass = new EClass(); |
| var resTest10a = contTest10.map mmnested3(outTest10a, "10: "); |
| assert fatal (contTest10.name = "10: 10: test10 10: 10: mm3 self mm1"); |
| assert fatal (outTest10a.name = "10: 10: mm3 out mm1"); |
| assert fatal (resTest10a.name = "result_name"); |
| |
| var outTest10b :EClass; |
| var resTest10b = contTest10.map mmnested2(outTest10b, "10: "); |
| assert fatal (contTest10.name = "10: 10: test10 10: 10: mm3 self mm1"); |
| assert fatal (outTest10b.name = "10: 10: mm3 out mm1"); |
| assert fatal (resTest10b.name = "result_name"); |
| |
| var outTest10c :EClassifier; |
| var resTest10c = contTest10.map mmnested1(outTest10c, "10: "); |
| assert fatal (contTest10.name = "10: 10: test10 10: 10: mm3 self mm1"); |
| assert fatal (outTest10c.name = "10: 10: mm3 out mm1"); |
| assert fatal (resTest10c.name = "result_name"); |
| } |
| |
| |
| helper fooHelper(inout param : Integer) { |
| param := 1; |
| return; |
| } |
| |
| helper fooHelper2(inout param : Set(String)) { |
| param := new Set(String) ("1","2"); |
| return; |
| } |
| |
| |
| mapping inout EClass :: m1(out outParam : EClassifier, in prefix:String) : EClass { |
| init { |
| outParam := new EClass(); |
| } |
| self.name := prefix + "self_name"; |
| outParam.name := prefix + "out_name"; |
| name := prefix + 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: m2(out outParam : EClass, in prefix:String) : EClass { |
| init { |
| outParam := new EClass(); |
| } |
| outParam.name := prefix + "out_name / " + self.name; |
| self.name := prefix + "self_name / " + self.name; |
| name := prefix + 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: m3(out outParam : List(String), in prefix:String) : EClass { |
| init { |
| outParam := new List(String)(); |
| outParam->add(prefix + "out_name / " + self.name); |
| } |
| self.name := prefix + "self_name / " + self.name; |
| name := prefix + 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: m4(out outParam : Bag(String), in prefix:String) : EClass { |
| init { |
| outParam := new Bag(String)(prefix + "out_name / " + self.name); |
| } |
| self.name := prefix + "self_name / " + self.name; |
| name := prefix + 'result_name'; |
| } |
| |
| |
| |
| mapping md1(in selfParam:EClass, out outParam1 : EClass) : EClass disjuncts md2, md3 |
| { |
| } |
| |
| mapping md2(in selfParam:EClass, out outParam2 : EClass) : EClass |
| when {selfParam.name = "name1";} |
| { |
| outParam2.name := 'out2 ' + selfParam.name; |
| } |
| |
| mapping md3(in selfParam:EClass, out outParam3 : EClass) : EClass |
| when {selfParam.name != "name1";} |
| { |
| outParam3.name := 'out3 ' + selfParam.name; |
| } |
| |
| |
| |
| mapping inout EClass :: mi1(out outParam : EClassifier, in prefix:String) : EClass { |
| init{} |
| self.name := self.name + outParam.name + " self mi1"; |
| outParam.name := outParam.name + " out mi1"; |
| name := 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: mi2(out outParam : EClass, in prefix:String) : EClass |
| inherits EClass::mi1 |
| { |
| init { |
| outParam := new EClass(); |
| outParam.name := "mi2"; |
| } |
| outParam.name := prefix + outParam.name; |
| self.name := prefix + self.name; |
| name := prefix + name; |
| } |
| |
| |
| mapping inout EClass :: mm1(out outParam : EClassifier, in prefix:String) : EClass { |
| init{ |
| } |
| self.name := self.name + outParam.name + " self mm1"; |
| outParam.name := outParam.name + " out mm1"; |
| name := 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: mm2(out outParam : EClass, in prefix:String) : EClass |
| merges EClass::mm1 |
| { |
| init { |
| outParam := new EClass(); |
| outParam.name := "mm2"; |
| } |
| outParam.name := prefix + outParam.name; |
| self.name := prefix + self.name; |
| name := prefix + name; |
| } |
| |
| mapping inout EClass :: mmnested1(out outParam : EClassifier, in prefix:String) : EClass { |
| init{ |
| } |
| self.name := self.name + outParam.name + " self mm1"; |
| outParam.name := outParam.name + " out mm1"; |
| name := 'result_name'; |
| } |
| |
| |
| mapping inout EClass :: mmnested2(out outParam : EClass, in prefix:String) : EClass |
| merges EClass::mmnested1 |
| { |
| init { |
| } |
| outParam.name := prefix + outParam.name; |
| self.name := prefix + self.name; |
| name := prefix + name; |
| } |
| |
| mapping inout EClass :: mmnested3(out outParam : EClass, in prefix:String) : EClass |
| merges EClass::mmnested2 |
| { |
| init { |
| outParam := new EClass(); |
| outParam.name := "mm3"; |
| } |
| outParam.name := prefix + outParam.name; |
| self.name := prefix + self.name; |
| name := prefix + name; |
| } |
| |