rgen 0.6.0 → 0.6.1

data/CHANGELOG

@@ -151,3 +151,13 @@
 * Fixed metamodel generator to quote illegal enum literal symbols
 * Imporved UML to ECore transformer and EA support
 
+=0.6.1
+
+* Fixed metamodel builder to not overwrite a model element's 'class' method
+* Added enum type transformation to ECoreToUML13 transformer, primitive type mapping based on instanceClassName
+* Fixed default value appearing on read after setting a feature value to nil
+* Added eIsSet and eUnset methods
+* Added eContainer and eContainingFeature methods
+* Fixed ModelFragment#elements not containing root elements
+* Added optional output of invalidation reason to FileCacheMap#load_data
+

data/README.rdoc

@@ -0,0 +1,78 @@
+= RGen - Ruby Modelling and Generator Framework
+
+RGen is a framework for Model Driven Software Development (MDSD)in Ruby.
+This means that it helps you build Metamodels, instantiate Models, modify
+and transform Models and finally generate arbitrary textual content from it.
+
+RGen features include:
+* Supporting Ruby 1.8.6, 1.8.7 and 1.9.x
+* Metamodel definition language (internal Ruby DSL)
+* ECore Meta-metamodel with an ECore instance available for every Metamodel
+* Generator creating the Ruby metamodel definition from an ECore instance
+* Transformer creating Ruby metamodel classes/modules from an ECore instance
+* Instantiation of Metamodels, i.e. creation of Models (e.g. from XML)
+* Model builder, internal Ruby DSL
+* Model fragmentation over several several files and per-fragment caching
+* Model Transformation language (internal Ruby DSL)
+* Powerful template based generator language (internal Ruby DSL inside of ERB)
+* UML 1.3 metamodel and XMI 1.1 instantiator included
+* ECore XML support (XMI 2.0)
+* UML-to-ECore and ECore-to-UML transformation (UML class models)
+* Enterprise Architect support (UML1.3/XMI1.1) 
+
+
+== Download
+
+Get the latest release from Github: https://github.com/mthiede/rgen
+
+
+== Installation
+
+Install RGen as a Ruby gem:
+
+  gem install rgen
+
+
+== Running the Tests 
+
+Change to the 'test' folder and run the test suite:
+
+  cd test
+  ruby rgen_test.rb
+
+
+== Documentation
+
+RDoc documentation is available at Github: http://mthiede.github.com/rgen/
+
+Find the main documentation parts for:
+* RGen::MetamodelBuilder
+* RGen::Transformer
+* RGen::TemplateLanguage
+* RGen::Fragment::FragmentedModel
+
+
+== Examples
+
+There are several examples of using RGen within the framework itself.
+
+Metamodel Definition:
+  lib/rgen/ecore/ecore.rb
+  lib/metamodels/uml13_metamodel.rb
+
+Instantiation:
+  lib/rgen/instantiator/xmi11_instantiator.rb
+  lib/rgen/instantiator/ecore_xml_instantiator.rb
+  
+Transformations:
+  lib/rgen/ecore/ruby_to_ecore.rb
+  lib/transformers/uml13_to_ecore.rb
+  
+Generators:
+  lib/mmgen/metamodel_generator.rb
+
+  
+== License
+
+RGen is released under the MIT license.
+

data/Rakefile

@@ -1,41 +1,37 @@
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
+require 'rubygems/package_task'
+require 'rdoc/task'
 
 RGenGemSpec = Gem::Specification.new do |s|
   s.name = %q{rgen}
-  s.version = "0.6.0"
+  s.version = "0.6.1"
   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}
   s.homepage = %q{http://ruby-gen.org}
   s.rubyforge_project = %q{rgen}
-  s.description = %q{RGen is a framework supporting Model Driven Software Development (MDSD). This means that it helps you build Metamodels, instantiate Models, modify and transform Models and finally generate arbitrary textual content from it.}
+  s.description = %q{RGen is a framework for Model Driven Software Development (MDSD) in Ruby. This means that it helps you build Metamodels, instantiate Models, modify and transform Models and finally generate arbitrary textual content from it.}
   s.authors = ["Martin Thiede"]
   gemfiles = Rake::FileList.new
   gemfiles.include("{lib,test}/**/*")
-  gemfiles.include("README", "CHANGELOG", "MIT-LICENSE", "Rakefile") 
+  gemfiles.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "Rakefile") 
   gemfiles.exclude(/\b\.bak\b/)
   s.files = gemfiles
-  s.rdoc_options = ["--main", "README", "-x", "test", "-x", "metamodels", "-x", "ea_support/uml13*"]
-  s.extra_rdoc_files = ["README", "CHANGELOG", "MIT-LICENSE"]
+  s.rdoc_options = ["--main", "README.rdoc", "-x", "test", "-x", "metamodels", "-x", "ea_support/uml13*"]
+  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "MIT-LICENSE"]
 end
 
-Rake::RDocTask.new do |rd|
-  rd.main = "README"
-  rd.rdoc_files.include("README", "CHANGELOG", "MIT-LICENSE", "lib/**/*.rb")
-  rd.rdoc_files.exclude("lib/metamodels")
+RDoc::Task.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "CHANGELOG", "MIT-LICENSE", "lib/**/*.rb")
+  rd.rdoc_files.exclude("lib/metamodels/*")
   rd.rdoc_files.exclude("lib/ea_support/uml13*")
   rd.rdoc_dir = "doc"
 end
 
-RGenPackageTask = Rake::GemPackageTask.new(RGenGemSpec) do |p|
-  p.need_zip = true
+RGenPackageTask = Gem::PackageTask.new(RGenGemSpec) do |p|
+  p.need_zip = false
 end	
 
-task :publish_doc do
-  sh %{pscp -r doc/* thiedem@rubyforge.org:/var/www/gforge-projects/rgen}
-end
-
 task :prepare_package_rdoc => :rdoc do
   RGenPackageTask.package_files.include("doc/**/*")
 end

data/lib/rgen/fragment/model_fragment.rb

@@ -99,6 +99,7 @@ class ModelFragment
     return @elements if @elements
     @elements = []
     @root_elements.each do |e|
+      @elements << e
       all_child_elements(e, @elements)
     end
     @elements

data/lib/rgen/metamodel_builder.rb

@@ -201,6 +201,9 @@ module MetamodelBuilder
 	
   # Instances of MMGeneric can be used as values of any attribute are reference
   class MMGeneric
+    # empty implementation so we don't have to check if a value is a MMGeneriv before setting the container
+    def _set_container(container, containing_feature_name)
+    end
   end
 
   # MMProxy objects can be used instead of real target elements in case references should be resolved later on

data/lib/rgen/metamodel_builder/builder_extensions.rb

@@ -306,18 +306,20 @@ module BuilderExtensions
     else
       @@one_read_builder ||= ERB.new <<-CODE
       
-        def <%= name %>
+        def get<%= firstToUpper(name) %>
           <% if !props.reference? && props.value(:defaultValueLiteral) %>
             <% defVal = props.value(:defaultValueLiteral) %>
             <% check_default_value_literal(defVal, props) %>
             <% defVal = '"'+defVal+'"' if props.impl_type == String %>
             <% defVal = ':'+defVal if props.impl_type.is_a?(DataTypes::Enum) && props.impl_type != DataTypes::Boolean %>
-            @<%= name %>.nil? ? <%= defVal %> : @<%= name %>
+            (defined? @<%= name %>) ? @<%= name %> : <%= defVal %>
           <% else %>
             @<%= name %>
           <% end %>
         end
-        alias get<%= firstToUpper(name) %> <%= name %>
+        <% if name != "class" %>
+          alias <%= name %> get<%= firstToUpper(name) %>
+        <% end %>
 
       CODE
       self::ClassModule.module_eval(@@one_read_builder.result(binding))
@@ -326,8 +328,8 @@ module BuilderExtensions
     if props.value(:changeable)
       @@one_write_builder ||= ERB.new <<-CODE
         
-        def <%= name %>=(val)
-          return if val == @<%= name %>
+        def set<%= firstToUpper(name) %>(val)
+          return if (defined? @<%= name %>) && val == @<%= name %>
           <%= type_check_code("val", props) %>
           oldval = @<%= name %>
           @<%= name %> = val
@@ -335,17 +337,28 @@ module BuilderExtensions
             oldval._unregister<%= firstToUpper(other_role) %>(self) unless oldval.nil? || oldval.is_a?(MMGeneric)
             val._register<%= firstToUpper(other_role) %>(self) unless val.nil? || val.is_a?(MMGeneric)
           <% end %>
+          <% if props.reference? && props.value(:containment) %>
+            val._set_container(self, :<%= name %>) unless val.nil?
+            oldval._set_container(nil, nil) unless oldval.nil?
+          <% end %>
         end 
-        alias set<%= firstToUpper(name) %> <%= name %>=
+        alias <%= name %>= set<%= firstToUpper(name) %>
 
         def _register<%= firstToUpper(name) %>(val)
           <% if other_role %>
             @<%= name %>._unregister<%= firstToUpper(other_role) %>(self) unless @<%= name %>.nil? || @<%= name %>.is_a?(MMGeneric)
           <% end %>
+          <% if props.reference? && props.value(:containment) %>
+            @<%= name %>._set_container(nil, nil) unless @<%= name %>.nil?
+            val._set_container(self, :<%= name %>) unless val.nil?
+          <% end %>
           @<%= name %> = val
         end
         
         def _unregister<%= firstToUpper(name) %>(val)
+          <% if props.reference? && props.value(:containment) %>
+            @<%= name %>._set_container(nil, nil) unless @<%= name %>.nil?
+          <% end %>
           @<%= name %> = nil
         end
         
@@ -366,10 +379,12 @@ module BuilderExtensions
     else
       @@many_read_builder ||= ERB.new <<-CODE
       
-        def <%= name %>
+        def get<%= firstToUpper(name) %>
           ( @<%= name %> ? @<%= name %>.dup : [] )
         end
-        alias get<%= firstToUpper(name) %> <%= name %>
+        <% if name != "class" %>
+          alias <%= name %> get<%= firstToUpper(name) %>
+        <% end %>
               
       CODE
       self::ClassModule.module_eval(@@many_read_builder.result(binding))
@@ -386,6 +401,9 @@ module BuilderExtensions
           <% if other_role %>
             val._register<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMGeneric)
           <% end %>
+          <% if props.reference? && props.value(:containment) %>
+            val._set_container(self, :<%= name %>)
+          <% end %>
         end
         
         def remove<%= firstToUpper(name) %>(val)
@@ -393,6 +411,9 @@ module BuilderExtensions
           @<%= name %>.each_with_index do |e,i|
             if e.object_id == val.object_id
               @<%= name %>.delete_at(i)
+              <% if props.reference? && props.value(:containment) %>
+                val._set_container(nil, nil)
+              <% end %>
               <% if other_role %>
                 val._unregister<%= firstToUpper(other_role) %>(self) unless val.is_a?(MMGeneric)
               <% end %>
@@ -401,7 +422,7 @@ module BuilderExtensions
           end    
         end
         
-        def <%= name %>=(val)
+        def set<%= firstToUpper(name) %>(val)
           return if val.nil?
           raise _assignmentTypeError(self, val, Enumerable) unless val.is_a? Enumerable
           get<%= firstToUpper(name) %>.each {|e|
@@ -411,15 +432,21 @@ module BuilderExtensions
             add<%= firstToUpper(name) %>(v)
           }
         end
-        alias set<%= firstToUpper(name) %> <%= name %>=
+        alias <%= name %>= set<%= firstToUpper(name) %>
         
         def _register<%= firstToUpper(name) %>(val)
           @<%= name %> = [] unless @<%= name %>
           @<%= name %>.push val
+          <% if props.reference? && props.value(:containment) %>
+            val._set_container(self, :<%= name %>)
+          <% end %>
         end
 
         def _unregister<%= firstToUpper(name) %>(val)
           @<%= name %>.delete val
+          <% if props.reference? && props.value(:containment) %>
+            val._set_container(nil, nil)
+          <% end %>
         end
         
       CODE
@@ -435,7 +462,7 @@ module BuilderExtensions
       if (public_instance_methods+protected_instance_methods+private_instance_methods).include?(name)
     @@derived_builder ||= ERB.new <<-CODE
     
-      def <%= name %>
+      def get<%= firstToUpper(name) %>
         raise "Derived feature requires public implementation of method <%= name %>_derived" \
           unless respond_to?(:<%= name+"_derived" %>)
         val = <%= name %>_derived
@@ -449,7 +476,9 @@ module BuilderExtensions
         <% end %>  
         val
       end
-      alias get<%= firstToUpper(name) %> <%= name %>
+      <% if name != "class" %>
+        alias <%= name %> get<%= firstToUpper(name) %>
+      <% end %>
       #TODO final_method :<%= name %>
       
     CODE

data/lib/rgen/metamodel_builder/builder_runtime.rb

@@ -52,6 +52,32 @@ module BuilderRuntime
     result
   end
 
+  def eIsSet(role)
+    eval("defined? @#{role}") != nil
+  end
+
+  def eUnset(role)
+    if respond_to?("add#{firstToUpper(role.to_s)}")
+      setGeneric(role, [])
+    else
+      setGeneric(role, nil)
+    end
+    remove_instance_variable("@#{role}")
+  end
+
+  def eContainer
+    @_container
+  end
+
+  def eContainingFeature
+    @_containing_feature_name
+  end
+
+  def _set_container(container, containing_feature_name)
+    @_container = container
+    @_containing_feature_name = containing_feature_name
+  end
+
 	def _assignmentTypeError(target, value, expected)
 		text = ""
 		if target

data/lib/rgen/util/file_cache_map.rb

@@ -26,22 +26,37 @@ class FileCacheMap
 
   # load data associated with file +key_path+
   # returns :invalid in case either the associated file or the cache file has changed
-  def load_data(key_path)
+  #
+  # options:
+  #  :invalidation_reasons:
+  #    an array which will receive symbols indicating why the cache is invalid:
+  #    :no_cachefile, :cachefile_corrupted, :keyfile_changed
+  #
+  def load_data(key_path, options={})
+    reasons = options[:invalidation_reasons] || []
     cf = cache_file(key_path)
-    return :invalid unless File.exist?(cf)
+    if !File.exist?(cf)
+      reasons << :no_cachefile
+      return :invalid 
+    end
     result = nil
     File.open(cf, "rb") do |f|
       header = f.read(41)
-      return :invalid unless header
+      if !header
+        reasons << :cachefile_corrupted
+        return :invalid
+      end
       checksum = header[0..39]
       data = f.read
       if calc_sha1(data) == checksum
         if calc_sha1_keydata(key_path) == data[0..39]
           result = data[41..-1]
         else
+          reasons << :keyfile_changed
           result = :invalid
         end
       else
+        reasons << :cachefile_corrupted
         result = :invalid
       end
     end 

data/lib/transformers/ecore_to_uml13.rb

@@ -8,6 +8,7 @@ class ECoreToUML13 < RGen::Transformer
   def transform
     trans(:class => EPackage)
     trans(:class => EClass)
+    trans(:class => EEnum)
   end
 
   transform EPackage, :to => UML13::Package do
@@ -28,10 +29,22 @@ class ECoreToUML13 < RGen::Transformer
     }
   end
   
+  transform EEnum, :to => UML13::Class do
+    {:name => name,
+      :namespace => trans(ePackage),
+      :feature => trans(eLiterals)
+    }
+  end
+
+  transform EEnumLiteral, :to => UML13::Attribute do
+    {:name => name }
+  end
+
   transform EAttribute, :to => UML13::Attribute do
-    _typemap = {EString => "string", EBoolean => "boolean", EInt => "int", EFloat => "float"}
+    _typemap = {"String" => "string", "Boolean" => "boolean", "Integer" => "int", "Float" => "float"}
     {:name => name, 
-     :taggedValue => [@env_out.new(UML13::TaggedValue, :tag => "type", :value => _typemap[eType] || "")] 
+     :taggedValue => [@env_out.new(UML13::TaggedValue, :tag => "type", 
+       :value => _typemap[eType.instanceClassName] || eType.name)] 
     }
   end
   
@@ -63,4 +76,4 @@ class ECoreToUML13 < RGen::Transformer
     @model ||= @env_out.new(UML13::Model, :name => "Model")
   end
   
-end
+end

data/test/metamodel_builder_test.rb

@@ -142,6 +142,16 @@ class MetamodelBuilderTest < Test::Unit::TestCase
       abstract
     end
 
+    class ContainedClass < RGen::MetamodelBuilder::MMBase
+    end
+
+    class ContainerClass < RGen::MetamodelBuilder::MMBase
+      contains_one_uni 'oneChildUni', ContainedClass
+      contains_one 'oneChild', ContainedClass, 'parentOne'
+      contains_many_uni 'manyChildUni', ContainedClass
+      contains_many 'manyChild', ContainedClass, 'parentMany'
+    end
+
   end
    
   def mm
@@ -167,6 +177,10 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal 123, sc.integerWithDefault
     assert_equal 0.123, sc.floatWithDefault
     assert_equal true, sc.boolWithDefault
+
+    # setting nil should not make the default value appear on next read
+    sc.stringWithDefault = nil
+    assert_nil sc.stringWithDefault
     
     sc.anything = :asymbol
     assert_equal :asymbol, sc.anything
@@ -224,19 +238,20 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     assert_equal ["a"], o.literals
     o.addLiterals("b")
     assert_equal ["a", "b"], o.literals
-    # check for duplicates works by object identity, so there can be two strings "b"
     o.addLiterals("b")
     assert_equal ["a", "b", "b"], o.literals
-    # but the same string object "a" can only occur once
+    # attributes allow the same object several times
     o.addLiterals(o.literals.first)
     assert_equal ["a", "b", "b", "a"], o.literals
+    assert o.literals[0].object_id == o.literals[3].object_id
     # removing works by object identity, so providing a new string won't delete an existing one
     o.removeLiterals("a")
     assert_equal ["a", "b", "b", "a"], o.literals
     theA = o.literals.first
+    # each remove command removes only one element: remove first "a"
     o.removeLiterals(theA)
     assert_equal ["b", "b", "a"], o.literals
-    # removing something which is not present has no effect
+    # remove second "a" (same object)
     o.removeLiterals(theA)
     assert_equal ["b", "b"], o.literals
     o.removeLiterals(o.literals.first)
@@ -843,4 +858,264 @@ class MetamodelBuilderTest < Test::Unit::TestCase
     end
   end
 
+  def test_isset_set_to_nil
+    e = mm::SimpleClass.new
+    assert_respond_to e, :name
+    assert !e.eIsSet(:name)
+    assert !e.eIsSet("name")
+    e.name = nil
+    assert e.eIsSet(:name)
+  end
+
+  def test_isset_set_to_default
+    e = mm::SimpleClass.new
+    assert !e.eIsSet(:stringWithDefault)
+    # set the default value
+    e.name = "xtest"
+    assert e.eIsSet(:name)
+  end
+
+  def test_isset_many_add
+    e = mm::ManyAttrClass.new
+    assert_equal [], e.literals
+    assert !e.eIsSet(:literals)
+    e.addLiterals("x")
+    assert e.eIsSet(:literals)
+  end
+
+  def test_isset_many_remove
+    e = mm::ManyAttrClass.new
+    assert_equal [], e.literals
+    assert !e.eIsSet(:literals)
+    # removing a value which is not there
+    e.removeLiterals("x")
+    assert e.eIsSet(:literals)
+  end
+
+  def test_isset_ref
+    ac = mm::AClassOO.new
+    bc = mm::BClassOO.new
+    assert !bc.eIsSet(:aClass)
+    assert !ac.eIsSet(:bClass)
+    bc.aClass = ac
+    assert bc.eIsSet(:aClass)
+    assert ac.eIsSet(:bClass)
+  end
+
+  def test_isset_ref_many
+    ac = mm::AClassMM.new
+    bc = mm::BClassMM.new
+    assert !bc.eIsSet(:aClasses)
+    assert !ac.eIsSet(:bClasses)
+    bc.aClasses = [ac]
+    assert bc.eIsSet(:aClasses)
+    assert ac.eIsSet(:bClasses)
+  end
+
+  def test_unset_nil
+    e = mm::SimpleClass.new
+    e.name = nil
+    assert e.eIsSet(:name)
+    e.eUnset(:name)
+    assert !e.eIsSet(:name)
+  end
+
+  def test_unset_string
+    e = mm::SimpleClass.new
+    e.name = "someone"
+    assert e.eIsSet(:name)
+    e.eUnset(:name)
+    assert !e.eIsSet(:name)
+  end
+
+  def test_unset_ref
+    ac = mm::AClassOO.new
+    bc = mm::BClassOO.new
+    bc.aClass = ac
+    assert bc.eIsSet(:aClass)
+    assert ac.eIsSet(:bClass)
+    assert_equal bc, ac.bClass
+    bc.eUnset(:aClass)
+    assert_nil bc.aClass
+    assert_nil ac.bClass
+    assert !bc.eIsSet(:aClass)
+    # opposite ref is nil but still "set"
+    assert ac.eIsSet(:bClass)
+  end
+
+  def test_unset_ref_many
+    ac = mm::AClassMM.new
+    bc = mm::BClassMM.new
+    bc.aClasses = [ac]
+    assert bc.eIsSet(:aClasses)
+    assert ac.eIsSet(:bClasses)
+    assert_equal [bc], ac.bClasses
+    bc.eUnset(:aClasses)
+    assert_equal [], bc.aClasses
+    assert_equal [], ac.bClasses
+    assert !bc.eIsSet(:aClasses)
+    # opposite ref is empty but still "set"
+    assert ac.eIsSet(:bClasses)
+  end
+
+  def test_unset_marshal
+    e = mm::SimpleClass.new
+    e.name = "someone"
+    e.eUnset(:name)
+    e2 = Marshal.load(Marshal.dump(e))
+    assert e.object_id != e2.object_id
+    assert !e2.eIsSet(:name)
+  end
+
+  def test_conainer_one_uni
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+    a.oneChildUni = b
+    assert_equal a, b.eContainer
+    assert_equal :oneChildUni, b.eContainingFeature
+    a.oneChildUni = c
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+    assert_equal a, c.eContainer
+    assert_equal :oneChildUni, c.eContainingFeature
+    a.oneChildUni = nil
+    assert_nil c.eContainer
+    assert_nil c.eContainingFeature
+  end
+
+  def test_container_many_uni
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    a.addManyChildUni(b)
+    assert_equal a, b.eContainer
+    assert_equal :manyChildUni, b.eContainingFeature
+    a.addManyChildUni(c)
+    assert_equal a, c.eContainer
+    assert_equal :manyChildUni, c.eContainingFeature
+    a.removeManyChildUni(b)
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+    assert_equal a, c.eContainer
+    assert_equal :manyChildUni, c.eContainingFeature
+    a.removeManyChildUni(c)
+    assert_nil c.eContainer
+    assert_nil c.eContainingFeature
+  end
+
+  def test_conainer_one_bi
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainerClass.new
+    d = mm::ContainedClass.new
+    a.oneChild = b
+    assert_equal a, b.eContainer
+    assert_equal :oneChild, b.eContainingFeature
+    c.oneChild = d 
+    assert_equal c, d.eContainer
+    assert_equal :oneChild, d.eContainingFeature
+    a.oneChild = d
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+    assert_equal a, d.eContainer
+    assert_equal :oneChild, d.eContainingFeature
+  end
+
+  def test_conainer_one_bi_rev
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainerClass.new
+    d = mm::ContainedClass.new
+    a.oneChild = b
+    assert_equal a, b.eContainer
+    assert_equal :oneChild, b.eContainingFeature
+    c.oneChild = d 
+    assert_equal c, d.eContainer
+    assert_equal :oneChild, d.eContainingFeature
+    d.parentOne = a
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+    assert_equal a, d.eContainer
+    assert_equal :oneChild, d.eContainingFeature
+  end
+
+  def test_conainer_one_bi_nil
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a.oneChild = b
+    assert_equal a, b.eContainer
+    assert_equal :oneChild, b.eContainingFeature
+    a.oneChild = nil 
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+  end
+
+  def test_conainer_one_bi_nil_rev
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    a.oneChild = b
+    assert_equal a, b.eContainer
+    assert_equal :oneChild, b.eContainingFeature
+    b.parentOne = nil 
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+  end
+
+  def test_container_many_bi
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    a.addManyChild(b)
+    a.addManyChild(c)
+    assert_equal a, b.eContainer
+    assert_equal :manyChild, b.eContainingFeature
+    assert_equal a, c.eContainer
+    assert_equal :manyChild, c.eContainingFeature
+    a.removeManyChild(b)
+    assert_nil b.eContainer
+    assert_nil b.eContainingFeature
+  end
+
+  def test_conainer_many_bi_steal
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    d = mm::ContainerClass.new
+    a.addManyChild(b)
+    a.addManyChild(c)
+    assert_equal a, b.eContainer
+    assert_equal :manyChild, b.eContainingFeature
+    assert_equal a, c.eContainer
+    assert_equal :manyChild, c.eContainingFeature
+    d.addManyChild(b)
+    assert_equal d, b.eContainer
+    assert_equal :manyChild, b.eContainingFeature
+  end
+
+  def test_conainer_many_bi_steal_ref
+    a = mm::ContainerClass.new
+    b = mm::ContainedClass.new
+    c = mm::ContainedClass.new
+    d = mm::ContainerClass.new
+    a.addManyChild(b)
+    a.addManyChild(c)
+    assert_equal a, b.eContainer
+    assert_equal :manyChild, b.eContainingFeature
+    assert_equal a, c.eContainer
+    assert_equal :manyChild, c.eContainingFeature
+    b.parentMany = d
+    assert_equal d, b.eContainer
+    assert_equal :manyChild, b.eContainingFeature
+  end
+
+  def test_container_generic
+    a = mm::ContainerClass.new
+    assert_nothing_raised do
+      a.oneChild = RGen::MetamodelBuilder::MMGeneric.new
+    end
+  end
+
 end