concrete 0.2.0

data/test/metamodel_test.rb

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/environment'
+require 'rgen/serializer/json_serializer'
+require 'rgen/instantiator/json_instantiator'
+require 'concrete/metamodel/concrete_mmm'
+require 'concrete/metamodel/ecore_to_concrete'
+
+class MetamodelTest < Test::Unit::TestCase
+  include Concrete::Metamodel
+
+  TestDir = File.dirname(__FILE__)+"/metamodel_test"
+  def test_ecore_to_concrete
+    env = RGen::Environment.new
+    outfile = TestDir + "/concrete_mmm_generated.js"
+    ECoreToConcrete.new(nil, env).trans(ConcreteMMM.ecore.eClasses)
+    File.open(outfile, "w") do |f|
+      ser = RGen::Serializer::JsonSerializer.new(f)
+      ser.serialize(env.find(:class => ConcreteMMM::Classifier).sort{|a,b| a.name <=> b.name})
+    end
+    assert_equal File.read(TestDir+"/concrete_mmm_expected.js").strip, File.read(outfile).strip
+  end
+
+  def test_json_roundtrip
+    env = RGen::Environment.new
+    inst = RGen::Instantiator::JsonInstantiator.new(env, ConcreteMMM)
+    infile = TestDir + "/concrete_mmm_expected.js"
+    inst.instantiate(File.read(infile))
+    outfile = TestDir + "/concrete_mmm_regenerated.js"
+    File.open(outfile, "w") do |f|
+      # mark unresolved references, there should be no unresolved references
+      ser = RGen::Serializer::JsonSerializer.new(f, :identifierProvider => proc{|e| e.is_a?(RGen::MetamodelBuilder::MMProxy) && "xxx"})
+      ser.serialize(env.find(:class => ConcreteMMM::Classifier).sort{|a,b| a.name <=> b.name})        
+    end
+    assert_equal File.read(infile).strip, File.read(outfile).strip
+  end
+
+end
+	

data/test/metamodel_test/concrete_mmm_expected.js

@@ -0,0 +1,19 @@
+[ { "_class": "Datatype", "name": "Boolean" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "features": [ 
+  { "_class": "Feature", "name": "abstract", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Boolean" },
+  { "_class": "Feature", "name": "superTypes", "kind": "reference", "lowerLimit": 0, "upperLimit": -1, "type": "/Class" },
+  { "_class": "Feature", "name": "features", "kind": "containment", "lowerLimit": 0, "upperLimit": -1, "type": "/Feature" }], "name": "Class" },
+{ "_class": "Class", "abstract": true, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" }], "name": "Classifier" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "name": "Datatype" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Datatype" ], "features": [ 
+  { "_class": "Feature", "name": "literals", "kind": "attribute", "lowerLimit": 0, "upperLimit": -1, "type": "/String" }], "name": "Enum" },
+{ "_class": "Class", "abstract": false, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" },
+  { "_class": "Feature", "name": "kind", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/FeatureKind" },
+  { "_class": "Feature", "name": "lowerLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "upperLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "type", "kind": "reference", "lowerLimit": 0, "upperLimit": 1, "type": "/Classifier" }], "name": "Feature" },
+{ "_class": "Enum", "literals": [ "attribute", "reference", "containment" ], "name": "FeatureKind" },
+{ "_class": "Datatype", "name": "Integer" },
+{ "_class": "Datatype", "name": "String" }]

data/test/metamodel_test/concrete_mmm_generated.js

@@ -0,0 +1,19 @@
+[ { "_class": "Datatype", "name": "Boolean" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "features": [ 
+  { "_class": "Feature", "name": "abstract", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Boolean" },
+  { "_class": "Feature", "name": "superTypes", "kind": "reference", "lowerLimit": 0, "upperLimit": -1, "type": "/Class" },
+  { "_class": "Feature", "name": "features", "kind": "containment", "lowerLimit": 0, "upperLimit": -1, "type": "/Feature" }], "name": "Class" },
+{ "_class": "Class", "abstract": true, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" }], "name": "Classifier" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "name": "Datatype" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Datatype" ], "features": [ 
+  { "_class": "Feature", "name": "literals", "kind": "attribute", "lowerLimit": 0, "upperLimit": -1, "type": "/String" }], "name": "Enum" },
+{ "_class": "Class", "abstract": false, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" },
+  { "_class": "Feature", "name": "kind", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/FeatureKind" },
+  { "_class": "Feature", "name": "lowerLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "upperLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "type", "kind": "reference", "lowerLimit": 0, "upperLimit": 1, "type": "/Classifier" }], "name": "Feature" },
+{ "_class": "Enum", "literals": [ "attribute", "reference", "containment" ], "name": "FeatureKind" },
+{ "_class": "Datatype", "name": "Integer" },
+{ "_class": "Datatype", "name": "String" }]

data/test/metamodel_test/concrete_mmm_regenerated.js

@@ -0,0 +1,19 @@
+[ { "_class": "Datatype", "name": "Boolean" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "features": [ 
+  { "_class": "Feature", "name": "abstract", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Boolean" },
+  { "_class": "Feature", "name": "superTypes", "kind": "reference", "lowerLimit": 0, "upperLimit": -1, "type": "/Class" },
+  { "_class": "Feature", "name": "features", "kind": "containment", "lowerLimit": 0, "upperLimit": -1, "type": "/Feature" }], "name": "Class" },
+{ "_class": "Class", "abstract": true, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" }], "name": "Classifier" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Classifier" ], "name": "Datatype" },
+{ "_class": "Class", "abstract": false, "superTypes": [ "/Datatype" ], "features": [ 
+  { "_class": "Feature", "name": "literals", "kind": "attribute", "lowerLimit": 0, "upperLimit": -1, "type": "/String" }], "name": "Enum" },
+{ "_class": "Class", "abstract": false, "features": [ 
+  { "_class": "Feature", "name": "name", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/String" },
+  { "_class": "Feature", "name": "kind", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/FeatureKind" },
+  { "_class": "Feature", "name": "lowerLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "upperLimit", "kind": "attribute", "lowerLimit": 0, "upperLimit": 1, "type": "/Integer" },
+  { "_class": "Feature", "name": "type", "kind": "reference", "lowerLimit": 0, "upperLimit": 1, "type": "/Classifier" }], "name": "Feature" },
+{ "_class": "Enum", "literals": [ "attribute", "reference", "containment" ], "name": "FeatureKind" },
+{ "_class": "Datatype", "name": "Integer" },
+{ "_class": "Datatype", "name": "String" }]

data/test/unit/external_identifier_provider_test.html

@@ -0,0 +1,138 @@
+<html>
+<head>
+  <title>Concrete Unit test file</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <script src="../../redist/prototype.js" type="text/javascript"></script>
+  <script src="../../redist/scriptaculous/unittest.js" type="text/javascript"></script>
+	<script type="text/javascript" language="javascript" charset="utf-8">
+	// <![CDATA[
+		var Concrete = {}
+	// ]]>
+	</script>
+  <script src="../../concrete/external_identifier_provider.js" type="text/javascript"></script>	
+  <link rel="stylesheet" href="test.css" type="text/css" />
+</head>
+<body>
+<h1>Concrete Unit test file</h1>
+<p>
+  Tests for external_identifier_provider.js
+</p>
+
+<!-- Log output -->
+<div id="testlog"> </div>
+
+<!-- Tests follow -->
+<script type="text/javascript" language="javascript" charset="utf-8">
+// <![CDATA[
+
+  var Index1 = 
+  [ { name: "Module1", elements: [
+      { name: "A", _class: "ClassA", elements: [
+        { name: "A1", _class: "ClassA" },
+        { name: "A2", _class: "ClassA" } ]},
+      { name: "B", _class: "ClassB", elements: [
+        { name: "B1", _class: "ClassB", elements:  // value of "elements" not an Array here
+          { name: "B11", _class: "ClassB" } } ]} ]}, 
+    { name: "Module2", elements: [
+      { name: "AA", _class: "ClassA", elements: [
+        { name: "AA1", _class: "ClassA" },
+        { name: "AA2", _class: "ClassAA" } ]} ]},
+    { name: "Module3", elements: [
+      { name: "A", _class: "ClassA", elements: [
+        { name: "A1", _class: "ClassA" }]}]}
+  ];
+
+  new Test.Unit.Runner({
+
+    testGetElementInfo: function() { with(this) {
+      var mmp = {metaclassesByName: {"ClassA": "ClassAType"}};
+      var ip = new Concrete.IndexBasedExternalIdentifierProvider(Index1, mmp);
+
+      var ei = ip.getElementInfo(undefined);
+      assertEqual(false, ei);
+
+      ei = ip.getElementInfo("/A/A1");
+      assertEqual("ClassAType", ei.type);
+      assertEqual("Module1", ei.module);
+       
+      ei = ip.getElementInfo("/A/A1", {ignoreModule: "Module1"});
+      assertEqual("ClassAType", ei.type);
+      assertEqual("Module3", ei.module);
+       
+      ei = ip.getElementInfo("A/A2");
+      assertEqual("ClassAType", ei.type);
+      assertEqual("Module1", ei.module);
+
+      // /A/A3 does not exist
+      assertEqual(false, ip.getElementInfo("/A/A3"));
+
+      ei = ip.getElementInfo("/AA/AA1");
+      assertEqual("ClassAType", ei.type);
+      assertEqual("Module2", ei.module);
+
+      // /AA/AA2 exists but the classname can not be found in metamodel provider
+      assertEqual(false, ip.getElementInfo("/AA/AA2"));
+    }},
+
+    testGetIdentifiers: function() { with(this) {
+      var mmp = {metaclassesByName: {}};
+      var ip = new Concrete.IndexBasedExternalIdentifierProvider(Index1, mmp);
+  
+      var classAType = {name: "ClassA", allSubTypes: function() {return []}};
+      var idents = ip.getIdentifiers(classAType);
+
+      assertEqual(7, idents.size());
+      assertEqual("/A", idents[0]);
+      assertEqual("/A/A1", idents[1]);
+      assertEqual("/A/A2", idents[2]);
+      assertEqual("/AA", idents[3]);
+      assertEqual("/AA/AA1", idents[4]);
+      assertEqual("/A", idents[5]);
+      assertEqual("/A/A1", idents[6]);
+
+      var classATypeWithSubtypes = {name: "ClassA", allSubTypes: function() {return [{name: "ClassAA", allSubTypes: function(){return []}}]}};
+      idents = ip.getIdentifiers(classATypeWithSubtypes);
+
+      assertEqual(8, idents.size());
+      assertEqual("/A", idents[0]);
+      assertEqual("/A/A1", idents[1]);
+      assertEqual("/A/A2", idents[2]);
+      assertEqual("/AA", idents[3]);
+      assertEqual("/AA/AA1", idents[4]);
+      assertEqual("/AA/AA2", idents[5]);
+      assertEqual("/A", idents[6]);
+      assertEqual("/A/A1", idents[7]);
+
+      var classBType = {name: "ClassB", allSubTypes: function() {return []}};
+      idents = ip.getIdentifiers(classBType);
+
+      assertEqual(3, idents.size());
+      assertEqual("/B", idents[0]);
+      assertEqual("/B/B1", idents[1]);
+      assertEqual("/B/B1/B11", idents[2]);
+    }}, 
+
+    testGetAllElementInfo: function() { with(this) {
+      var mmp = {metaclassesByName: {}};
+      var ip = new Concrete.IndexBasedExternalIdentifierProvider(Index1, mmp);
+
+      var eis = ip.getAllElementInfo();
+
+      assertEqual(11, eis.size());
+      assertEqual("/A", eis[0].identifier);
+      assertEqual("ClassA", eis[0].type);
+      assertEqual("Module1", eis[0].module);
+      assertEqual("/B/B1/B11", eis[5].identifier);
+      assertEqual("ClassB", eis[5].type);
+      assertEqual("Module1", eis[5].module);
+      assertEqual("/A/A1", eis[10].identifier);
+      assertEqual("ClassA", eis[10].type);
+      assertEqual("Module3", eis[10].module);
+    }}
+
+  });
+
+// ]]>
+</script>
+</body>
+</html>  

data/test/unit/identifier_provider_test.html

@@ -0,0 +1,269 @@
+<html>
+<head>
+  <title>Concrete Unit test file</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <script src="../../redist/prototype.js" type="text/javascript"></script>
+  <script src="../../redist/scriptaculous/unittest.js" type="text/javascript"></script>
+	<script type="text/javascript" language="javascript" charset="utf-8">
+	// <![CDATA[
+		var Concrete = {}
+	// ]]>
+	</script>
+  <script src="../../concrete/helper.js" type="text/javascript"></script>	
+  <script src="../../concrete/element_extension.js" type="text/javascript"></script>	
+  <script src="../../concrete/identifier_provider.js" type="text/javascript"></script>	
+  <link rel="stylesheet" href="test.css" type="text/css" />
+</head>
+<body>
+<h1>Concrete Unit test file</h1>
+<p>
+  Tests for identifier_provider.js
+</p>
+
+<!-- Log output -->
+<div id="testlog"> </div>
+
+<div id="testModelSource" style="display: none">
+	<!-- two nested elements -->
+	<div class="ct_element">
+		<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E1</span></span></span>
+		<div class="ct_containment"><div class="ct_slot">
+			<div class="ct_element">
+				<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E11</span></span></span>
+			</div>
+		</div></div>
+	</div>
+	<!-- two nested elements with some div in between and multiple child elements -->
+	<div>
+		<div class="ct_element">
+			<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E2</span></span></span>
+			<div>
+				<div class="ct_containment"><div class="ct_slot">
+					<div class="ct_element">
+						<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E21</span></span></span>
+					</div>
+					<div class="ct_element">
+						<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E22</span></span></span>
+					</div>
+				</div></div>
+				<div class="ct_containment"><div class="ct_slot">
+					<div class="ct_element">
+						<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E23</span></span></span>
+					</div>
+				</div></div>
+			</div>
+		</div>
+	</div>
+	<!-- two nested elements with other elements in between which don't have names -->
+	<div>
+		<div class="ct_element"> <!-- no name -->
+			<div class="ct_containment"><div class="ct_slot">
+				<div class="ct_element"> <!-- E3 -->
+					<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E3</span></span></span>
+					<div class="ct_containment"><div class="ct_slot">
+						<div class="ct_element"> <!-- no name -->
+							<div class="ct_containment"><div class="ct_slot">
+								<div class="ct_element"> <!-- E31 -->
+									<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E31</span></span></span>
+								</div>
+							</div></div>
+						</div>
+					</div></div>
+				</div>
+			</div></div>
+		</div>
+	</div>
+	<!-- duplicate identifier E1 -->
+	<div class="ct_element">
+		<span class="ct_attribute"><span class="ct_slot"><span class="ct_value">E1</span></span></span>
+	</div>
+</div>
+
+<div id="testModel" class="ct_root">
+</div>
+
+<!-- Tests follow -->
+<script type="text/javascript" language="javascript" charset="utf-8">
+// <![CDATA[
+
+  new Test.Unit.Runner({
+
+    setup: function() {
+    	var testModel = $('testModel');
+    	testModel.innerHTML = $('testModelSource').innerHTML;
+    	setupModel(testModel);
+    },
+		
+    testSimple: function() { with(this) {
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+    	    	
+    	var e1 = rootElements[0];
+    	var e1e11 = rootElements[0].down(".ct_element");
+		
+    	ip.elementAdded(e1);
+
+    	assertEqual("/E1", ip.getIdentifier(e1));
+    	assertEqual(e1, ip.getElement("/E1"));
+    	assertEqual("/E1/E11", ip.getIdentifier(e1e11));
+    	assertEqual(e1e11, ip.getElement("/E1/E11"));
+    	
+    	var e2 = rootElements[1].down(".ct_element");
+    	var e2e21 = rootElements[1].down(".ct_element").select(".ct_element")[0];
+    	var e2e22 = rootElements[1].down(".ct_element").select(".ct_element")[1];
+    	var e2e23 = rootElements[1].down(".ct_element").select(".ct_element")[2];
+    	
+    	ip.elementAdded(e2);
+    	
+    	assertEqual("/E2", ip.getIdentifier(e2));
+    	assertEqual("/E2/E21", ip.getIdentifier(e2e21));
+    	assertEqual("/E2/E22", ip.getIdentifier(e2e22));
+    	assertEqual("/E2/E23", ip.getIdentifier(e2e23));
+    	assertEqual(e2, ip.getElement("/E2"));
+    	assertEqual(e2e21, ip.getElement("/E2/E21"));
+    	assertEqual(e2e22, ip.getElement("/E2/E22"));
+    	assertEqual(e2e23, ip.getElement("/E2/E23"));
+    	
+    	var e3 = rootElements[2].down(".ct_element").down(".ct_element");
+    	var e3e31 = rootElements[2].down(".ct_element").down(".ct_element").down(".ct_element").down(".ct_element");
+    	
+    	ip.elementAdded(e3);
+    	
+    	assertEqual("/E3", ip.getIdentifier(e3));
+    	assertEqual("/E3/E31", ip.getIdentifier(e3e31));
+    	assertEqual(e3, ip.getElement("/E3"));
+    	assertEqual(e3e31, ip.getElement("/E3/E31"));
+		}},
+		
+    testRename: function() { with(this) {
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+    	    	
+    	var e1 = rootElements[0];
+    	var e1e11 = rootElements[0].down(".ct_element");
+
+    	ip.elementAdded(e1);
+
+			var value = e1.down(".ct_attribute").down(".ct_value")
+      value.textContent = "X";
+      value.value = value.textContent;
+
+    	ip.elementChanged(e1, undefined);
+
+    	assertEqual("/X", ip.getIdentifier(e1));
+    	assertEqual(undefined, ip.getElement("/E1"));
+    	assertEqual(e1, ip.getElement("/X"));
+    	assertEqual("/X/E11", ip.getIdentifier(e1e11));
+    	assertEqual(undefined, ip.getElement("/E1/E11"));
+    	assertEqual(e1e11, ip.getElement("/X/E11"));
+		}},
+
+    testRemoveName: function() { with(this) {
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+    	    	
+    	var e1 = rootElements[0];
+    	var e1e11 = rootElements[0].down(".ct_element");
+
+    	ip.elementAdded(e1);
+
+			e1.down(".ct_attribute").down(".ct_value").remove();
+
+    	ip.elementChanged(e1, undefined);
+    	assertEqual(undefined, ip.getIdentifier(e1));
+    	assertEqual(undefined, ip.getElement("/E1"));
+    	assertEqual("/E11", ip.getIdentifier(e1e11));
+    	assertEqual(undefined, ip.getElement("/E1/E11"));
+    	assertEqual(e1e11, ip.getElement("/E11"));
+    }},
+    
+    testRemoveElement: function() { with(this) {
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+    	    	
+    	var e1 = rootElements[0];
+    	var e1e11 = rootElements[0].down(".ct_element");
+
+    	ip.elementAdded(e1);
+    	ip.elementRemoved(e1);
+
+    	assertEqual(undefined, ip.getIdentifier(e1));
+    	assertEqual(undefined, ip.getElement("/E1"));
+    	assertEqual(undefined, ip.getIdentifier(e1e11));
+    	assertEqual(undefined, ip.getElement("/E1/E11"));
+		}},
+			    
+		testBeforeChange: function() { with(this) {	
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+    	    	
+    	var e1 = rootElements[0];
+    	var e1e11 = rootElements[0].down(".ct_element");
+
+    	assertEqual(undefined, ip.getIdentifier(e1));
+    	assertEqual(undefined, ip.getElement("/E1"));
+    	assertEqual(undefined, ip.getIdentifier(e1e11));
+    	assertEqual(undefined, ip.getElement("/E1/E11"));
+		}},
+		
+		testDuplicateIdentifier: function() { with(this) {
+    	var root = $('testModel');
+    	var rootElements = root.childElements();
+    	var ip = new Concrete.QualifiedNameBasedIdentifierProvider({nameAttribute: "name", separator: "/", leadingSeparator: true});
+
+    	var e1 = rootElements[0];
+    	var e4 = rootElements[3];
+		
+    	ip.elementAdded(e1);
+    	assertEqual("/E1", ip.getIdentifier(e1));
+    	assertEqual(e1, ip.getElement("/E1"));
+
+    	ip.elementAdded(e4);
+    	// e1 still has its old identifier
+    	assertEqual("/E1", ip.getIdentifier(e1));
+    	// e4 has the same identifier
+    	assertEqual("/E1", ip.getIdentifier(e4));
+    	// getElement returns an Array holding e1 and e4
+    	assertEqual(2, ip.getElement("/E1").size());
+    	assertEqual(e1, ip.getElement("/E1")[0]);
+    	assertEqual(e4, ip.getElement("/E1")[1]);
+    	
+    	ip.elementRemoved(e1);
+    	assertEqual(e4, ip.getElement("/E1"));
+    	
+    	ip.elementRemoved(e4)
+    	assertEqual(undefined, ip.getElement("/E1"));
+    }},
+       
+  })
+  
+  function setupModel(root) {
+  	root.select(".ct_element").each(function(e) {
+  		e.features = e.findFirstDescendants(["ct_attribute", "ct_reference", "ct_containment"], ["ct_element"]);
+  		var i = 1;
+  		e.features.each(function(f) {
+  			f.slot = f.down(".ct_slot");
+  			if (f.hasClassName("ct_attribute")) {
+  				f.mmFeature = {name: "name", kind: "attribute", type: "String"};
+  				f.mmFeature.isContainment = function() { return false; };  				
+  			}
+  			else if (f.hasClassName("ct_containment")) {
+  				f.mmFeature = {name: "sub"+i, kind: "containment"};
+  				f.mmFeature.isContainment = function() { return true; };
+  			}
+        f.slot.select(".ct_value").each(function(v) {
+          v.value = v.textContent;
+        });
+  			i++;
+  		});
+		});
+  }
+// ]]>
+</script>
+</body>
+</html>