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;
}