rgen 0.6.6 → 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe212a74ff9c45d6fcd848596acb527d6def24f5
+  data.tar.gz: 3c99d2170dab24b922a30a5a5420f03aaa05779e
+SHA512:
+  metadata.gz: a70a59af207fcf7d3c35c0f8785a9bcceebb370b9a0f41e07a2103bc563256acd6e5160d256c1e8c786d52f48f9e540ed62e2105348b9b9a520a57f9d0a99c0b
+  data.tar.gz: eae33d63df0964a0175917aa7efd711306e933a4ab56fa938976a5d28eb8fc53a3e7e18e984a4c89dd134d0421418f6d86ff02a60c1e7e011620a544a62b6edd

data/CHANGELOG

@@ -186,3 +186,12 @@
 * Major performance improvement of FragmentedModel#resolve
 * Fixed a Ruby 2.0 related warning
 
+=0.7.0
+
+* Enforce unique container rule by automatically disconnecting elements from other containers
+* Added support for long typed values (ELong), thanks to Thomas Hallgren;
+  Note that this is merely an EMF compatibility thing, RGen could already handle big integers before
+* Added eContents and eAllContents methods
+* Added setNilOrRemoveGeneric and setNilOrRemoveAllGeneric methods
+* Added disconnectContainer method
+

data/Rakefile

@@ -3,7 +3,7 @@ require 'rdoc/task'
 
 RGenGemSpec = Gem::Specification.new do |s|
   s.name = %q{rgen}
-  s.version = "0.6.6"
+  s.version = "0.7.0"
   s.date = Time.now.strftime("%Y-%m-%d")
   s.summary = %q{Ruby Modelling and Generator Framework}
   s.email = %q{martin dot thiede at gmx de}

data/lib/rgen/ecore/ecore.rb

@@ -54,7 +54,7 @@ module RGen
         def defaultValue_derived
           return nil if defaultValueLiteral.nil?
           case eType
-            when EInt
+            when EInt, ELong
               defaultValueLiteral.to_i
             when EFloat
               defaultValueLiteral.to_f
@@ -81,7 +81,10 @@ module RGen
       has_attr 'instanceClassName', String
       module ClassModule
         def instanceClass_derived
-          map = {"java.lang.string" => "String", "boolean" => "RGen::MetamodelBuilder::DataTypes::Boolean", "int" => "Integer"}
+          map = {"java.lang.string" => "String", 
+                 "boolean" => "RGen::MetamodelBuilder::DataTypes::Boolean", 
+                 "int" => "Integer",
+                 "long" => "RGen::MetamodelBuilder::DataTypes::Long"}
           icn = instanceClassName
           icn = "NilClass" if icn.nil?
           icn = map[icn.downcase] if map[icn.downcase]
@@ -181,6 +184,7 @@ module RGen
     
     EString = EDataType.new(:name => "EString", :instanceClassName => "String")
     EInt = EDataType.new(:name => "EInt", :instanceClassName => "Integer")
+    ELong = EDataType.new(:name => "ELong", :instanceClassName => "Long")
     EBoolean = EDataType.new(:name => "EBoolean", :instanceClassName => "Boolean")
     EFloat = EDataType.new(:name => "EFloat", :instanceClassName => "Float")
     ERubyObject = EDataType.new(:name => "ERubyObject", :instanceClassName => "Object")

data/lib/rgen/fragment/model_fragment.rb

@@ -111,7 +111,7 @@ class ModelFragment
     @elements = []
     @root_elements.each do |e|
       @elements << e
-      all_child_elements(e, @elements)
+      @elements.concat(e.eAllContents)
     end
     @elements
   end
@@ -274,21 +274,6 @@ class ModelFragment
     end
   end
 
-  def all_child_elements(element, childs)
-    containment_references(element.class).each do |r|
-      element.getGenericAsArray(r.name).each do |c|
-        childs << c
-        all_child_elements(c, childs)
-      end
-    end
-  end
-
-  def containment_references(clazz)
-    @@containment_references_cache ||= {}
-    @@containment_references_cache[clazz] ||=
-      clazz.ecore.eAllReferences.select{|r| r.containment}
-  end
-
   def non_containment_references(clazz)
     @@non_containment_references_cache ||= {}
     @@non_containment_references_cache[clazz] ||= 

data/lib/rgen/instantiator/ecore_xml_instantiator.rb

@@ -84,7 +84,7 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
     elsif eFeat
       value = true if value == "true" && eFeat.eType == EBoolean
       value = false if value == "false" && eFeat.eType == EBoolean
-      value = value.to_i if eFeat.eType == EInt
+      value = value.to_i if eFeat.eType == EInt || eFeat.eType == ELong
       @elementstack.last.setGeneric(attr, value)
     else
       log WARN, "Feature not found: #{attr} on #{@elementstack.last}"
@@ -134,6 +134,7 @@ class ECoreXMLInstantiator < AbstractXMLInstantiator
         case $1
           when "EString";     RGen::ECore::EString
           when "EInt";        RGen::ECore::EInt
+          when "ELong";       RGen::ECore::ELong
           when "EBoolean";    RGen::ECore::EBoolean
           when "EFloat";      RGen::ECore::EFloat
           when "EJavaObject"; RGen::ECore::EJavaObject

data/lib/rgen/instantiator/xmi11_instantiator.rb

@@ -116,7 +116,7 @@ class XMI11Instantiator < AbstractXMLInstantiator
         value = map_feature_value(attr_name, value) || value
         value = true if value == "true" && eFeat.eType == EBoolean
         value = false if value == "false" && eFeat.eType == EBoolean
-        value = value.to_i if eFeat.eType == EInt
+        value = value.to_i if eFeat.eType == EInt || eFeat.eType == ELong
         value = value.to_f if eFeat.eType == EFloat
         value = value.to_sym if eFeat.eType.is_a?(EEnum)
         @elementstack.last.setGeneric(attr_name, value)

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -487,7 +487,7 @@ module BuilderExtensions
 
   def check_default_value_literal(literal, props)
     return if literal.nil? || props.impl_type == String
-    if props.impl_type == Integer
+    if props.impl_type == Integer || props.impl_type == RGen::MetamodelBuilder::DataTypes::Long
       unless literal =~ /^\d+$/
         raise StandardError.new("Property #{props.value(:name)} can not take value #{literal}, expected an Integer")
       end
@@ -510,7 +510,11 @@ module BuilderExtensions
   
   def type_check_code(varname, props)
     code = ""
-    if props.impl_type.is_a?(Class)
+    if props.impl_type == RGen::MetamodelBuilder::DataTypes::Long
+      code << "unless #{varname}.nil? || #{varname}.is_a?(Integer) || #{varname}.is_a?(MMGeneric)"
+      code << "\n"
+      expected = "Integer"
+    elsif props.impl_type.is_a?(Class)
       code << "unless #{varname}.nil? || #{varname}.is_a?(#{props.impl_type}) || #{varname}.is_a?(MMGeneric)"
       code << " || #{varname}.is_a?(BigDecimal)" if props.impl_type == Float && defined?(BigDecimal)
       code << "\n"

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -42,6 +42,22 @@ module BuilderRuntime
     end
   end
 
+  def setNilOrRemoveGeneric(role, value)
+    if hasManyMethods(role)
+      removeGeneric(role, value)
+    else
+      setGeneric(role, nil)
+    end
+  end
+
+  def setNilOrRemoveAllGeneric(role)
+    if hasManyMethods(role)
+      setGeneric(role, [])
+    else
+      setGeneric(role, nil)
+    end
+  end
+
 	def getGeneric(role)
 		send("get#{firstToUpper(role.to_s)}")
 	end
@@ -73,11 +89,70 @@ module BuilderRuntime
     @_containing_feature_name
   end
 
+  # returns the contained elements in no particular order
+  def eContents
+    if @_contained_elements
+      @_contained_elements.dup
+    else
+      []
+    end
+  end
+
+  # if a block is given, calls the block on every contained element in depth first order. 
+  # if the block returns :prune, recursion will stop at this point.
+  #
+  # if no block is given builds and returns a list of all contained elements.
+  #
+  def eAllContents(&block)
+    if block
+      if @_contained_elements
+        @_contained_elements.each do |e|
+          res = block.call(e)
+          e.eAllContents(&block) if res != :prune
+        end
+      end
+      nil
+    else
+      result = []
+      if @_contained_elements
+        @_contained_elements.each do |e|
+          result << e
+          result.concat(e.eAllContents)
+        end
+      end
+      result
+    end
+  end
+
+  def disconnectContainer
+    eContainer.setNilOrRemoveGeneric(eContainingFeature, self) if eContainer
+  end
+
   def _set_container(container, containing_feature_name)
+    # if a new container is set, make sure to disconnect from the old one.
+    # note that _set_container will never be called for the container and the role
+    # which are currently set because the accessor methods in BuilderExtensions
+    # block setting/adding a value which is already present.
+    # (it may be called for the same container with a different role, a different container
+    # with the same role and a different container with a different role, though)
+    # this ensures, that disconnecting for the current container doesn't break
+    # a new connection which has just been set up in the accessor methods.
+    disconnectContainer if container
+    @_container._remove_contained_element(self) if @_container
+    container._add_contained_element(self) if container
     @_container = container
     @_containing_feature_name = containing_feature_name
   end
 
+  def _add_contained_element(element)
+    @_contained_elements ||= []
+    @_contained_elements << element
+  end
+
+  def _remove_contained_element(element)
+    @_contained_elements.delete(element) if @_contained_elements
+  end
+
 	def _assignmentTypeError(target, value, expected)
 		text = ""
 		if target

data/lib/rgen/metamodel_builder/data_types.rb

@@ -65,6 +65,11 @@ module DataTypes
 	# as possible values.
 	Boolean = Enum.new(:name => "Boolean", :literals => [true, false])
 
+	# Long represents a 64-bit Integer
+  # This constant is merely a marker for keeping this information in the Ruby version of the metamodel,
+  # values of this type will always be instances of Integer or Bignum;
+  # Setting it to a string value ensures that it responds to "to_s" which is used in the metamodel generator
+	Long = "Long"
 end
 
 end

data/lib/rgen/metamodel_builder/intermediate/feature.rb

@@ -67,6 +67,7 @@ class Attribute < Feature
   Types = { 
     String => :EString,
     Integer => :EInt,
+    RGen::MetamodelBuilder::DataTypes::Long => :ELong,
     Float => :EFloat,
     RGen::MetamodelBuilder::DataTypes::Boolean => :EBoolean,
     Object => :ERubyObject,

data/lib/rgen/serializer/xmi20_serializer.rb

@@ -57,6 +57,7 @@ class XMI20Serializer < XMLSerializer
     pre = "ecore:EDataType http://www.eclipse.org/emf/2002/Ecore"
     @referenceStrings[RGen::ECore::EString] = pre+"#//EString"
     @referenceStrings[RGen::ECore::EInt] = pre+"#//EInt"
+    @referenceStrings[RGen::ECore::ELong] = pre+"#//ELong"
     @referenceStrings[RGen::ECore::EFloat] = pre+"#//EFloat"
     @referenceStrings[RGen::ECore::EBoolean] = pre+"#//EBoolean"
     @referenceStrings[RGen::ECore::EJavaObject] = pre+"#//EJavaObject"

data/test/metamodel_builder_test.rb

@@ -15,6 +15,7 @@ class MetamodelBuilderTest < Test::Unit::TestCase
       has_attr 'name' # default is String
       has_attr 'stringWithDefault', String, :defaultValueLiteral => "xtest"
       has_attr 'integerWithDefault', Integer, :defaultValueLiteral => "123"
+      has_attr 'longWithDefault', Long, :defaultValueLiteral => "1234567890"
       has_attr 'floatWithDefault', Float, :defaultValueLiteral => "0.123"
       has_attr 'boolWithDefault', Boolean, :defaultValueLiteral => "true"
       has_attr 'anything', Object
@@ -148,9 +149,17 @@ class MetamodelBuilderTest < Test::Unit::TestCase
 
     class ContainerClass < RGen::MetamodelBuilder::MMBase
       contains_one_uni 'oneChildUni', ContainedClass
+      contains_one_uni 'oneChildUni2', ContainedClass
       contains_one 'oneChild', ContainedClass, 'parentOne'
+      contains_one 'oneChild2', ContainedClass, 'parentOne2'
       contains_many_uni 'manyChildUni', ContainedClass
+      contains_many_uni 'manyChildUni2', ContainedClass
       contains_many 'manyChild', ContainedClass, 'parentMany'
+      contains_many 'manyChild2', ContainedClass, 'parentMany2'
+    end
+
+    class NestedContainerClass < ContainedClass
+      contains_one_uni 'oneChildUni', ContainedClass
     end
 
     class OppositeRefAssocA < RGen::MetamodelBuilder::MMBase
@@ -183,6 +192,7 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal "xtest", sc.stringWithDefault
     assert_equal :extended, sc.kindWithDefault
     assert_equal 123, sc.integerWithDefault
+    assert_equal 1234567890, sc.longWithDefault
     assert_equal 0.123, sc.floatWithDefault
     assert_equal true, sc.boolWithDefault
 
@@ -253,6 +263,20 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert sc2.floatWithDefault.is_a?(BigDecimal)
     assert_equal "123456789012345678.0", sc2.floatWithDefault.to_s("F")
   end
+
+  def test_long
+    sc = mm::SimpleClass.new
+    sc.longWithDefault = 5
+    assert_equal 5, sc.longWithDefault
+    sc.longWithDefault = 1234567890
+    assert_equal 1234567890, sc.longWithDefault
+    assert sc.longWithDefault.is_a?(Bignum)
+    assert sc.longWithDefault.is_a?(Integer)
+    err = assert_raise StandardError do
+      sc.longWithDefault = "a string"
+    end
+    assert_match /In (\w+::)+SimpleClass : Can not use a String where a Integer is expected/, err.message
+  end
   
   def test_many_attr
     o = mm::ManyAttrClass.new
@@ -807,6 +831,8 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal [e1], e2.aClasses
   end
   
+  # Multiplicity agnostic convenience methods
+
   def test_genericAccess
     e1 = mm::OneClass.new
     e2 = mm::ManyClass.new
@@ -826,6 +852,40 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal [], e4.getGenericAsArray("oneClass")
   end
 
+  def test_setNilOrRemoveGeneric
+    e1 = mm::OneClass.new
+    e2 = mm::ManyClass.new
+    e3 = mm::OneClass.new
+    # use on "many" feature
+    e1.addManyClasses(e2)
+    assert_equal [e2], e1.manyClasses
+    e1.setNilOrRemoveGeneric("manyClasses", e2)
+    assert_equal [], e1.manyClasses
+    # use on "one" feature
+    e2.oneClass = e3
+    assert_equal e3, e2.oneClass
+    e2.setNilOrRemoveGeneric("oneClass", e3)
+    assert_nil e2.oneClass
+  end
+
+  def test_setNilOrRemoveAllGeneric
+    e1 = mm::OneClass.new
+    e2 = mm::ManyClass.new
+    e3 = mm::OneClass.new
+    e4 = mm::ManyClass.new
+    # use on "many" feature
+    e1.addManyClasses(e2)
+    e1.addManyClasses(e4)
+    assert_equal [e2, e4], e1.manyClasses
+    e1.setNilOrRemoveAllGeneric("manyClasses")
+    assert_equal [], e1.manyClasses
+    # use on "one" feature
+    e2.oneClass = e3
+    assert_equal e3, e2.oneClass
+    e2.setNilOrRemoveAllGeneric("oneClass")
+    assert_nil e2.oneClass
+  end
+
   def test_abstract
     err = assert_raise StandardError do
       mm::AbstractClass.new
@@ -871,6 +931,11 @@ class MetamodelBuilderTest < Test::Unit::TestCase
         has_attr 'enumWithDefault', kindType, :defaultValueLiteral => "7"
       end
     end
+    Test8 = proc do 
+      class BadClass < RGen::MetamodelBuilder::MMBase
+        has_attr 'longWithDefault', Integer, :defaultValueLiteral => "1.1"
+      end
+    end
   end
 
   def test_bad_default_value_literal
@@ -902,6 +967,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
       BadDefaultValueLiteralContainer::Test7.call
     end
     assert_equal "Property enumWithDefault can not take value 7, expected one of :simple, :extended", err.message
+    err = assert_raise StandardError do
+      BadDefaultValueLiteralContainer::Test8.call
+    end
+    assert_equal "Property longWithDefault can not take value 1.1, expected an Integer", err.message
   end
 
   def test_isset_set_to_nil
@@ -1017,39 +1086,57 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     a = mm::ContainerClass.new
     b = mm::ContainedClass.new
     c = mm::ContainedClass.new
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
     a.oneChildUni = b
     assert_equal a, b.eContainer
     assert_equal :oneChildUni, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     a.oneChildUni = c
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
     assert_equal a, c.eContainer
     assert_equal :oneChildUni, c.eContainingFeature
+    assert_equal [c], a.eContents
+    assert_equal [c], a.eAllContents
     a.oneChildUni = nil
     assert_nil c.eContainer
     assert_nil c.eContainingFeature
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
   end
 
   def test_container_many_uni
     a = mm::ContainerClass.new
     b = mm::ContainedClass.new
     c = mm::ContainedClass.new
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
     a.addManyChildUni(b)
     assert_equal a, b.eContainer
     assert_equal :manyChildUni, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     a.addManyChildUni(c)
     assert_equal a, c.eContainer
     assert_equal :manyChildUni, c.eContainingFeature
+    assert_equal [b, c], a.eContents
+    assert_equal [b, c], a.eAllContents
     a.removeManyChildUni(b)
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
     assert_equal a, c.eContainer
     assert_equal :manyChildUni, c.eContainingFeature
+    assert_equal [c], a.eContents
+    assert_equal [c], a.eAllContents
     a.removeManyChildUni(c)
     assert_nil c.eContainer
     assert_nil c.eContainingFeature
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
   end
 
   def test_conainer_one_bi
@@ -1060,14 +1147,22 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     a.oneChild = b
     assert_equal a, b.eContainer
     assert_equal :oneChild, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     c.oneChild = d 
     assert_equal c, d.eContainer
     assert_equal :oneChild, d.eContainingFeature
+    assert_equal [d], c.eContents
+    assert_equal [d], c.eAllContents
     a.oneChild = d
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
     assert_equal a, d.eContainer
     assert_equal :oneChild, d.eContainingFeature
+    assert_equal [d], a.eContents
+    assert_equal [d], a.eAllContents
+    assert_equal [], c.eContents
+    assert_equal [], c.eAllContents
   end
 
   def test_conainer_one_bi_rev
@@ -1078,14 +1173,22 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     a.oneChild = b
     assert_equal a, b.eContainer
     assert_equal :oneChild, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     c.oneChild = d 
     assert_equal c, d.eContainer
     assert_equal :oneChild, d.eContainingFeature
+    assert_equal [d], c.eContents
+    assert_equal [d], c.eAllContents
     d.parentOne = a
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
     assert_equal a, d.eContainer
     assert_equal :oneChild, d.eContainingFeature
+    assert_equal [d], a.eContents
+    assert_equal [d], a.eAllContents
+    assert_equal [], c.eContents
+    assert_equal [], c.eAllContents
   end
 
   def test_conainer_one_bi_nil
@@ -1094,9 +1197,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     a.oneChild = b
     assert_equal a, b.eContainer
     assert_equal :oneChild, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     a.oneChild = nil 
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
   end
 
   def test_conainer_one_bi_nil_rev
@@ -1105,9 +1212,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     a.oneChild = b
     assert_equal a, b.eContainer
     assert_equal :oneChild, b.eContainingFeature
+    assert_equal [b], a.eContents
+    assert_equal [b], a.eAllContents
     b.parentOne = nil 
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
+    assert_equal [], a.eContents
+    assert_equal [], a.eAllContents
   end
 
   def test_container_many_bi
@@ -1120,9 +1231,13 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal :manyChild, b.eContainingFeature
     assert_equal a, c.eContainer
     assert_equal :manyChild, c.eContainingFeature
+    assert_equal [b, c], a.eContents
+    assert_equal [b, c], a.eAllContents
     a.removeManyChild(b)
     assert_nil b.eContainer
     assert_nil b.eContainingFeature
+    assert_equal [c], a.eContents
+    assert_equal [c], a.eAllContents
   end
 
   def test_conainer_many_bi_steal
@@ -1136,12 +1251,18 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal :manyChild, b.eContainingFeature
     assert_equal a, c.eContainer
     assert_equal :manyChild, c.eContainingFeature
+    assert_equal [b, c], a.eContents
+    assert_equal [b, c], a.eAllContents
     d.addManyChild(b)
     assert_equal d, b.eContainer
     assert_equal :manyChild, b.eContainingFeature
+    assert_equal [c], a.eContents
+    assert_equal [c], a.eAllContents
+    assert_equal [b], d.eContents
+    assert_equal [b], d.eAllContents
   end
 
-  def test_conainer_many_bi_steal_ref
+  def test_conainer_many_bi_steal_rev
     a = mm::ContainerClass.new
     b = mm::ContainedClass.new
     c = mm::ContainedClass.new
@@ -1152,9 +1273,51 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal :manyChild, b.eContainingFeature
     assert_equal a, c.eContainer
     assert_equal :manyChild, c.eContainingFeature
+    assert_equal [b, c], a.eContents
+    assert_equal [b, c], a.eAllContents
     b.parentMany = d
     assert_equal d, b.eContainer
     assert_equal :manyChild, b.eContainingFeature
+    assert_equal [c], a.eContents
+    assert_equal [c], a.eAllContents
+    assert_equal [b], d.eContents
+    assert_equal [b], d.eAllContents
+  end
+
+  def test_all_contents
+    a = mm::ContainerClass.new
+    b = mm::NestedContainerClass.new
+    c = mm::ContainedClass.new
+    a.oneChildUni = b
+    b.oneChildUni = c
+    assert_equal [b, c], a.eAllContents
+  end
+
+  def test_all_contents_with_block
+    a = mm::ContainerClass.new
+    b = mm::NestedContainerClass.new
+    c = mm::ContainedClass.new
+    a.oneChildUni = b
+    b.oneChildUni = c
+    yielded = []
+    a.eAllContents do |e|
+      yielded << e
+    end
+    assert_equal [b, c], yielded
+  end
+
+  def test_all_contents_prune
+    a = mm::ContainerClass.new
+    b = mm::NestedContainerClass.new
+    c = mm::ContainedClass.new
+    a.oneChildUni = b
+    b.oneChildUni = c
+    yielded = []
+    a.eAllContents do |e|
+      yielded << e
+      :prune
+    end
+    assert_equal [b], yielded
   end
 
   def test_container_generic
@@ -1198,4 +1361,122 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal [], a.manyChildUni
   end
 
+  def test_disconnectContainer_one_uni
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a.oneChildUni = b
+    b.disconnectContainer
+    assert_nil a.oneChildUni
+  end
+
+  def test_disconnectContainer_one
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a.oneChild = b
+    b.disconnectContainer
+    assert_nil a.oneChild
+    assert_nil b.parentOne
+  end
+
+  def test_disconnectContainer_many_uni
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    a.addManyChildUni(b)
+    a.addManyChildUni(c)
+    b.disconnectContainer
+    assert_equal [c], a.manyChildUni
+  end
+
+  def test_disconnectContainer_many
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    a.addManyChild(b)
+    a.addManyChild(c)
+    b.disconnectContainer
+    assert_nil b.parentMany
+    assert_equal [c], a.manyChild
+  end
+
+  # Duplicate Containment Tests
+  #
+  # Testing that no element is contained in two different containers at a time.
+  # This must also work for uni-directional containments as well as
+  # for containments via different roles.
+
+  # here the bi-dir reference disconnects from the previous container
+  def test_duplicate_containment_bidir_samerole_one
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.oneChild = b
+    a2.oneChild = b
+    assert_nil a1.oneChild
+  end
+
+  # here the bi-dir reference disconnects from the previous container
+  def test_duplicate_containment_bidir_samerole_many
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.addManyChild(b)
+    a2.addManyChild(b)
+    assert_equal [], a1.manyChild
+  end
+
+  def test_duplicate_containment_unidir_samerole_one
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.oneChildUni = b
+    a2.oneChildUni = b
+    assert_nil a1.oneChildUni
+  end
+
+  def test_duplicate_containment_unidir_samerole_many
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.addManyChildUni(b)
+    a2.addManyChildUni(b)
+    assert_equal [], a1.manyChildUni
+  end
+
+  def test_duplicate_containment_bidir_otherrole_one
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.oneChild = b
+    a2.oneChild2 = b
+    assert_nil a1.oneChild
+  end
+
+  def test_duplicate_containment_bidir_otherrole_many
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.addManyChild(b)
+    a2.addManyChild2(b)
+    assert_equal [], a1.manyChild
+  end
+
+  def test_duplicate_containment_unidir_otherrole_one
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.oneChildUni = b
+    a2.oneChildUni2 = b
+    assert_nil a1.oneChildUni
+  end
+
+  def test_duplicate_containment_unidir_otherrole_many
+    a1 = mm::ContainerClass.new
+    a2 = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a1.addManyChildUni(b)
+    a2.addManyChildUni2(b)
+    assert_equal [], a1.manyChildUni
+  end
+
 end