rgen 0.3.0 → 0.4.0

data/redist/xmlscan/tests/testxmlchar.rb

@@ -0,0 +1,143 @@
+#
+# tests/xmlchar.rb
+#
+#   Copyright (C) Ueno Katsuhiro 2002
+#
+# $Id: testxmlchar.rb,v 1.4 2005/05/22 07:07:12 nahi Exp $
+#
+
+require 'test/unit'
+require 'deftestcase'
+require 'xmlscan/xmlchar'
+require 'visitor'
+
+
+class TestXMLChar < Test::Unit::TestCase
+
+  include XMLScan::XMLChar
+
+  def test_valid_char_p
+    assert_equal true, valid_char?(9)
+    assert_equal true, valid_char?(10)
+    assert_equal true, valid_char?(13)
+    assert_equal true, valid_char?(32)
+    assert_equal false, valid_char?(8)
+    assert_equal true, valid_char?(0xfffd)
+    assert_equal false, valid_char?(0xfffe)
+    assert_equal false, valid_char?(0xffff)
+    assert_equal false, valid_char?(0x200000)
+  end
+
+
+  # \xE3\x81\xBB = ho
+  # \xE3\x81\x92 = ge
+  # \xE3\x81\xB5 = fu
+  # \xE3\x81\x8C = ga
+
+  Hoge = "\xE3\x81\xBB\xE3\x81\x92"
+  Fuga = "\xE3\x81\xB5\xE3\x81\x8C"
+
+  Testcases = [
+    #                   chardata? nmtoken?    name?
+    [ 'hogefuga',           true,    true,    true ],
+    [ Hoge+Fuga,            true,    true,    true ],
+    [ Hoge+' '+Fuga,        true,   false,   false ],
+    [ Hoge+"\n"+Fuga,       true,   false,   false ],
+    [ Hoge+"\r"+Fuga,       true,   false,   false ],
+    [ Hoge+"\t"+Fuga,       true,   false,   false ],
+    [ Hoge+"\f"+Fuga,      false,   false,   false ],
+    [ Hoge+'.'+Fuga,        true,    true,    true ],
+    [ Hoge+'-'+Fuga,        true,    true,    true ],
+    [ Hoge+'_'+Fuga,        true,    true,    true ],
+    [ Hoge+':'+Fuga,        true,    true,    true ],
+    [ Hoge+'%'+Fuga,        true,   false,   false ],
+    [ '.'+Hoge+Fuga,        true,    true,   false ],
+    [ '-'+Hoge+Fuga,        true,    true,   false ],
+    [ '_'+Hoge+Fuga,        true,    true,    true ],
+    [ ':'+Hoge+Fuga,        true,    true,    true ],
+    [ '%'+Hoge+Fuga,        true,   false,   false ],
+    [ Hoge+"\xfe"+Fuga,    false,   false,   false ],
+    [ Hoge+"\xff"+Fuga,    false,   false,   false ],
+    [ [0xffff].pack('U'),  false,   false,   false ],
+  ]
+
+
+  def test_valid_chardata_p
+    Testcases.each { |str,expect,|
+      assert_equal expect, valid_chardata?(str), str.inspect
+    }
+  end
+
+  def test_valid_nmtoken_p
+    Testcases.each { |str,dummy,expect,|
+      assert_equal expect, valid_nmtoken?(str), str.inspect
+    }
+  end
+
+  def test_valid_name_p
+    Testcases.each { |str,dummy,dummy,expect,|
+      assert_equal expect, valid_name?(str), str.inspect
+    }
+  end
+
+end
+
+
+
+class TestXMLScannerStrict < Test::Unit::TestCase
+
+  include DefTestCase
+
+  Visitor = RecordingVisitor.new_class(XMLScan::Visitor)
+
+
+  private
+
+  def setup
+    @origkcode = $KCODE
+    $KCODE = 'U'
+    @v = Visitor.new
+    @s = XMLScan::XMLScanner.new(@v, :strict_char)
+  end
+
+  def teardown
+    $KCODE = @origkcode
+  end
+
+  def parse(src)
+    @s.parse src
+    @v.result
+  end
+
+
+  public
+
+  Hoge = TestXMLChar::Hoge
+  Fuga = TestXMLChar::Fuga
+
+
+  deftestcase 'document', <<-'TESTCASEEND'
+
+  "<:.#{Hoge}>hoge</:.#{Hoge}>"
+  [ :on_stag, ":.#{Hoge}" ]
+  [ :on_stag_end, ":.#{Hoge}" ]
+  [ :on_chardata, "hoge" ]
+  [ :on_etag, ":.#{Hoge}" ]
+
+  "<.:#{Hoge}>hoge</.:#{Hoge}>"
+  [ :parse_error, "`.:#{Hoge}' is not valid for XML name"]
+  [ :on_stag, ".:#{Hoge}" ]
+  [ :on_stag_end, ".:#{Hoge}" ]
+  [ :on_chardata, "hoge" ]
+  [ :parse_error, "`.:#{Hoge}' is not valid for XML name"]
+  [ :on_etag, ".:#{Hoge}" ]
+
+  TESTCASEEND
+
+end
+
+
+
+
+
+load "#{File.dirname($0)}/runtest.rb" if __FILE__ == $0

data/redist/xmlscan/tests/visitor.rb

@@ -0,0 +1,34 @@
+#
+# tests/visitor.rb
+#
+#   Copyright (C) UENO Katsuhiro 2002
+#
+# $Id: visitor.rb,v 1.3 2002/09/24 21:39:30 katsu Exp $
+#
+
+module RecordingVisitor
+
+  def initialize
+    @result = []
+  end
+
+  attr_reader :result
+
+  def self.new_class(visitor)
+    klass = Class.new
+    mod = self
+    klass.module_eval { include mod, visitor }
+    methods = visitor.instance_methods
+    visitor.included_modules.each { |i| methods.concat i.instance_methods }
+    methods.sort.uniq.each { |i|
+      klass.module_eval <<-END, __FILE__, __LINE__ + 1
+        def #{i}(*args)
+          @result.push [ :#{i} ].concat(args)
+        end
+      END
+    }
+    klass
+  end
+
+
+end

data/test/array_extensions_test.rb

@@ -23,8 +23,8 @@ class ArrayExtensionsTest < Test::Unit::TestCase
 	end
 	
 	class MMBaseClass < RGen::MetamodelBuilder::MMBase
-		has_one 'name'
-		has_one 'age'
+		has_attr 'name'
+		has_attr 'age', Integer
 	end
 	
 	def test_with_mmbase

data/test/ea_instantiator_test.rb

@@ -0,0 +1,41 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/environment'
+require 'metamodels/uml13_metamodel'
+require 'instantiators/ea_instantiator'
+require 'transformers/uml13_to_ecore'
+require 'testmodel/class_model_checker'
+require 'testmodel/object_model_checker'
+require 'testmodel/ecore_model_checker'
+
+class EAInstantiatorTest < Test::Unit::TestCase
+
+    include Testmodel::ClassModelChecker
+    include Testmodel::ObjectModelChecker
+    include Testmodel::ECoreModelChecker
+    
+	MODEL_DIR = File.join(File.dirname(__FILE__),"testmodel")
+		
+	def test_instantiator
+		envUML = RGen::Environment.new
+		File.open(MODEL_DIR+"/ea_testmodel.xml") { |f|
+			inst = EAInstantiator.new(envUML, EAInstantiator::ERROR)
+			inst.instantiate(f.read)
+		}
+        checkClassModel(envUML)
+        checkObjectModel(envUML)
+        envECore = RGen::Environment.new
+        UML13ToECore.new(envUML, envECore).transform
+        checkECoreModel(envECore)
+	end
+	
+	def test_partial
+		envUML = RGen::Environment.new
+		File.open(MODEL_DIR+"/ea_testmodel_partial.xml") { |f|
+			inst = EAInstantiator.new(envUML, EAInstantiator::ERROR)
+			inst.instantiate(f.read)
+		}
+		checkClassModelPartial(envUML)
+	end
+end

data/test/ecore_self_test.rb

@@ -0,0 +1,53 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/ecore/ecore'
+require 'rgen/array_extensions'
+
+class ECoreSelfTest < Test::Unit::TestCase
+	include RGen::ECore
+	
+	def test_simple
+		assert_equal \
+			%w(lowerBound ordered unique upperBound many required eType).sort,
+			ETypedElement.ecore.eStructuralFeatures.name.sort
+			
+		assert_equal \
+			EClassifier.ecore,
+			ETypedElement.ecore.eStructuralFeatures.find{|f| f.name=="eType"}.eType
+		assert_equal %w(ENamedElement),	ETypedElement.ecore.eSuperTypes.name
+
+		assert_equal \
+			EModelElement.ecore,
+			EModelElement.ecore.eStructuralFeatures.find{|f| f.name=="eAnnotations"}.eOpposite.eType
+
+		assert_equal \
+			%w(eType),
+			ETypedElement.ecore.eReferences.name
+			
+		assert_equal \
+			%w(lowerBound ordered unique upperBound many required).sort,
+			ETypedElement.ecore.eAttributes.name.sort
+			
+		assert RGen::ECore.ecore.is_a?(EPackage)
+		assert_equal "ECore", RGen::ECore.ecore.name
+		assert_equal "RGen", RGen::ECore.ecore.eSuperPackage.name
+		assert_equal %w(ECore), RGen.ecore.eSubpackages.name
+		assert_equal\
+			%w(EObject EModelElement EAnnotation ENamedElement ETypedElement 
+				EStructuralFeature EAttribute EClassifier EDataType EEnum EEnumLiteral EFactory
+				EOperation EPackage EParameter EReference EStringToStringMapEntry EClass).sort,
+			RGen::ECore.ecore.eClassifiers.name.sort
+			
+        assert_equal "false", EAttribute.ecore.eAllAttributes.
+          find{|a|a.name == "derived"}.defaultValueLiteral
+        assert_equal false, EAttribute.ecore.eAllAttributes.
+          find{|a|a.name == "derived"}.defaultValue
+
+        assert_nil EAttribute.ecore.eAllAttributes.
+          find{|a|a.name == "defaultValueLiteral"}.defaultValueLiteral
+        assert_nil EAttribute.ecore.eAllAttributes.
+          find{|a|a.name == "defaultValueLiteral"}.defaultValue
+
+	end
+end

data/test/environment_test.rb

@@ -18,25 +18,30 @@ class EnvironmentTest < Test::Unit::TestCase
 		m2 = ModelSub.new
 		m2.name = "M2"
 		m3 = "justAString"
-		env_in = RGen::Environment.new << m1 << m2 << m3
-
-		result = env_in.find(:class => Model, :name => "M1")
+		env = RGen::Environment.new << m1 << m2 << m3
+		assertFind(env, m1, m2, m3)
+		idx = env.findIndex(:name)
+		assertFind(idx, m1, m2, m3)
+	end
+	
+	def assertFind(context, m1, m2, m3)
+		result = context.find(:class => Model, :name => "M1")
 		assert result.is_a?(Array)
 		assert_equal 1, result.size
 		assert_equal m1, result.first
 
-		result = env_in.find(:class => Model)
+		result = context.find(:class => Model)
 		assert result.is_a?(Array)
 		assert_equal 2, result.size
 		assert_equal m1, result[0]
 		assert_equal m2, result[1]
 		
-		result = env_in.find(:name => "M2")
+		result = context.find(:name => "M2")
 		assert result.is_a?(Array)
 		assert_equal 1, result.size
 		assert_equal m2, result[0]		
 		
-		result = env_in.find(:class => [Model, String])
+		result = context.find(:class => [Model, String])
 		assert result.is_a?(Array)
 		assert_equal 3, result.size
 		assert_equal m1, result[0]

data/test/metamodel_builder_test.rb

@@ -2,260 +2,419 @@ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 require 'test/unit'
 require 'rgen/metamodel_builder'
+require 'rgen/array_extensions'
 
 class MetamodelBuilderTest < Test::Unit::TestCase
+  
+  class SimpleClass < RGen::MetamodelBuilder::MMBase
+    KindType = RGen::MetamodelBuilder::DataTypes::Enum.new([:simple, :extended])
+    has_attr 'name' # default is String
+    has_attr 'stringWithDefault', String, :defaultValueLiteral => "xtest"
+    has_attr 'anything', Object
+    has_attr 'allowed', RGen::MetamodelBuilder::DataTypes::Boolean
+    has_attr 'kind', KindType
+    has_attr 'kindWithDefault', KindType, :defaultValueLiteral => "extended"
+  end
+  
+  def test_has_attr
+    sc = SimpleClass.new
+    
+    assert_respond_to sc, :name
+    assert_respond_to sc, :name=
+    sc.name = "TestName"
+    assert_equal "TestName", sc.name
+    sc.name = nil
+    assert_equal nil, sc.name
+    assert_raise StandardError do
+      sc.name = 5
+    end
+    assert_equal "EString", SimpleClass.ecore.eAttributes.find{|a| a.name=="name"}.eType.name
 
-	class HasOneTestClass < RGen::MetamodelBuilder::MMBase
-		has_one 'name'
-		has_one 'an_array', Array
-	end
-	
-	def test_has_one
-		sc = HasOneTestClass.new
-		assert_respond_to sc, :name
-		assert_respond_to sc, :name=
-		sc.name = 'SomeName'
-		assert_equal 'SomeName', sc.name
-		sc.name = nil
-		assert_equal nil, sc.name
+    assert_equal "xtest", sc.stringWithDefault
+    assert_equal :extended, sc.kindWithDefault
+    
+    sc.anything = :asymbol
+    assert_equal :asymbol, sc.anything
+    sc.anything = self # a class
+    assert_equal self, sc.anything
+    
+    assert_respond_to sc, :allowed
+    assert_respond_to sc, :allowed=
+    sc.allowed = true
+    assert_equal true, sc.allowed
+    sc.allowed = false
+    assert_equal false, sc.allowed
+    sc.allowed = nil
+    assert_equal nil, sc.allowed
+    assert_raise StandardError do
+      sc.allowed = :someSymbol
+    end
+    assert_raise StandardError do
+      sc.allowed = "a string"
+    end
+    assert_equal "EBoolean", SimpleClass.ecore.eAttributes.find{|a| a.name=="allowed"}.eType.name
+    
+    assert_respond_to sc, :kind
+    assert_respond_to sc, :kind=
+    sc.kind = :simple
+    assert_equal :simple, sc.kind
+    sc.kind = :extended
+    assert_equal :extended, sc.kind
+    sc.kind = nil
+    assert_equal nil, sc.kind
+    assert_raise StandardError do
+      sc.kind = :false
+    end
+    assert_raise StandardError do
+      sc.kind = "a string"
+    end
+    
+    enum = SimpleClass.ecore.eAttributes.find{|a| a.name=="kind"}.eType
+    assert_equal ["extended", "simple"], enum.eLiterals.name.sort
+  end
+  
+  class ClassA < RGen::MetamodelBuilder::MMBase
+  end
+  
+  class ClassB < RGen::MetamodelBuilder::MMBase
+  end
+  
+  class ClassC < RGen::MetamodelBuilder::MMBase
+  end
+  
+  class HasOneTestClass < RGen::MetamodelBuilder::MMBase
+    has_one 'classA', ClassA
+    has_one 'classB', ClassB
+  end
+  
+  def test_has_one
+    sc = HasOneTestClass.new
+    assert_respond_to sc, :classA
+    assert_respond_to sc, :classA=
+    ca = ClassA.new
+    sc.classA = ca
+    assert_equal ca, sc.classA
+    sc.classA = nil
+    assert_equal nil, sc.classA
+    
+    assert_respond_to sc, :classB
+    assert_respond_to sc, :classB=
+    cb = ClassB.new
+    sc.classB = cb
+    assert_equal cb, sc.classB
+    
+    assert_raise StandardError do
+      sc.classB = ca
+    end
+    
+    assert_equal [], ClassA.ecore.eReferences
+    assert_equal [], ClassB.ecore.eReferences
+    assert_equal ["classA", "classB"].sort, HasOneTestClass.ecore.eReferences.name.sort
+    assert_equal [], HasOneTestClass.ecore.eReferences.select { |a| a.many == true }
+    assert_equal [], HasOneTestClass.ecore.eAttributes
+  end
+  
+  class HasManyTestClass < RGen::MetamodelBuilder::MMBase
+    has_many 'classA', ClassA
+  end
+  
+  def test_has_many
+    o = HasManyTestClass.new
+    ca1 = ClassA.new
+    ca2 = ClassA.new
+    ca3 = ClassA.new
+    o.addClassA(ca1)
+    o.addClassA(ca2)
+    assert_equal [ca1, ca2], o.classA
+    # make sure we get a copy
+    o.classA.clear
+    assert_equal [ca1, ca2], o.classA
+    o.removeClassA(ca3)
+    assert_equal [ca1, ca2], o.classA
+    o.removeClassA(ca2)
+    assert_equal [ca1], o.classA
+    assert_raise StandardError do
+      o.addClassA(ClassB.new)
+    end
+    assert_equal [], HasManyTestClass.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["classA"], HasManyTestClass.ecore.eReferences.select{|r| r.many == true}.name
+  end
+  
+  class OneClass < RGen::MetamodelBuilder::MMBase
+  end
+  class ManyClass < RGen::MetamodelBuilder::MMBase
+  end
+  OneClass.one_to_many 'manyClasses', ManyClass, 'oneClass'
+  
+  def test_one_to_many
+    oc = OneClass.new
+    assert_respond_to oc, :manyClasses
+    assert oc.manyClasses.empty?
+    
+    mc = ManyClass.new
+    assert_respond_to mc, :oneClass
+    assert_respond_to mc, :oneClass=
+    assert_nil mc.oneClass
+    
+    # put the OneClass into the ManyClass
+    mc.oneClass = oc
+    assert_equal oc, mc.oneClass
+    assert oc.manyClasses.include?(mc)
+    
+    # remove the OneClass from the ManyClass
+    mc.oneClass = nil
+    assert_equal nil, mc.oneClass
+    assert !oc.manyClasses.include?(mc)
+    
+    # put the ManyClass into the OneClass
+    oc.addManyClasses mc
+    assert oc.manyClasses.include?(mc)
+    assert_equal oc, mc.oneClass
+    
+    # remove the ManyClass from the OneClass
+    oc.removeManyClasses mc
+    assert !oc.manyClasses.include?(mc)
+    assert_equal nil, mc.oneClass
+    
+    assert_equal [], OneClass.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["manyClasses"], OneClass.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal ["oneClass"], ManyClass.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], ManyClass.ecore.eReferences.select{|r| r.many == true}
+  end
+  
+  class OneClass2 < RGen::MetamodelBuilder::MMBase
+  end
+  class ManyClass2 < RGen::MetamodelBuilder::MMBase
+  end
+  ManyClass2.many_to_one 'oneClass', OneClass2, 'manyClasses'
+  
+  def test_one_to_many2
+    oc = OneClass2.new
+    assert_respond_to oc, :manyClasses
+    assert oc.manyClasses.empty?
+    
+    mc = ManyClass2.new
+    assert_respond_to mc, :oneClass
+    assert_respond_to mc, :oneClass=
+    assert_nil mc.oneClass
+    
+    # put the OneClass into the ManyClass
+    mc.oneClass = oc
+    assert_equal oc, mc.oneClass
+    assert oc.manyClasses.include?(mc)
+    
+    # remove the OneClass from the ManyClass
+    mc.oneClass = nil
+    assert_equal nil, mc.oneClass
+    assert !oc.manyClasses.include?(mc)
+    
+    # put the ManyClass into the OneClass
+    oc.addManyClasses mc
+    assert oc.manyClasses.include?(mc)
+    assert_equal oc, mc.oneClass
+    
+    # remove the ManyClass from the OneClass
+    oc.removeManyClasses mc
+    assert !oc.manyClasses.include?(mc)
+    assert_equal nil, mc.oneClass
+    
+    assert_equal [], OneClass2.ecore.eReferences.select{|r| r.many == false}
+    assert_equal ["manyClasses"], OneClass2.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal ["oneClass"], ManyClass2.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], ManyClass2.ecore.eReferences.select{|r| r.many == true}
+  end
+  
+  class AClassOO < RGen::MetamodelBuilder::MMBase
+  end
+  class BClassOO < RGen::MetamodelBuilder::MMBase
+  end
+  AClassOO.one_to_one 'bClass', BClassOO, 'aClass'
+  
+  def test_one_to_one
+    ac = AClassOO.new
+    assert_respond_to ac, :bClass
+    assert_respond_to ac, :bClass=
+    assert_nil ac.bClass
+    
+    bc = BClassOO.new
+    assert_respond_to bc, :aClass
+    assert_respond_to bc, :aClass=
+    assert_nil bc.aClass
+    
+    # put the AClass into the BClass
+    bc.aClass = ac
+    assert_equal ac, bc.aClass
+    assert_equal bc, ac.bClass
+    
+    # remove the AClass from the BClass
+    bc.aClass = nil
+    assert_equal nil, bc.aClass
+    assert_equal nil, ac.bClass
+    
+    # put the BClass into the AClass
+    ac.bClass = bc
+    assert_equal bc, ac.bClass
+    assert_equal ac, bc.aClass
+    
+    # remove the BClass from the AClass
+    ac.bClass = nil
+    assert_equal nil, ac.bClass
+    assert_equal nil, bc.aClass
+    
+    assert_equal ["bClass"], AClassOO.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], AClassOO.ecore.eReferences.select{|r| r.many == true}
+    assert_equal ["aClass"], BClassOO.ecore.eReferences.select{|r| r.many == false}.name
+    assert_equal [], BClassOO.ecore.eReferences.select{|r| r.many == true}
+  end
+  
+  class AClassMM < RGen::MetamodelBuilder::MMBase
+  end
+  class BClassMM < RGen::MetamodelBuilder::MMBase
+  end
+  AClassMM.many_to_many 'bClasses', BClassMM, 'aClasses'
+  
+  def test_many_to_many
+    
+    ac = AClassMM.new
+    assert_respond_to ac, :bClasses
+    assert ac.bClasses.empty?
+    
+    bc = BClassMM.new
+    assert_respond_to bc, :aClasses
+    assert bc.aClasses.empty?
+    
+    # put the AClass into the BClass
+    bc.addAClasses ac
+    assert bc.aClasses.include?(ac)
+    assert ac.bClasses.include?(bc)
+    
+    # put something else into the BClass
+    assert_raise StandardError do
+      bc.addAClasses :notaaclass
+    end
+    
+    # remove the AClass from the BClass
+    bc.removeAClasses ac
+    assert !bc.aClasses.include?(ac)
+    assert !ac.bClasses.include?(bc)
+    
+    # put the BClass into the AClass
+    ac.addBClasses bc
+    assert ac.bClasses.include?(bc)
+    assert bc.aClasses.include?(ac)
+    
+    # put something else into the AClass
+    assert_raise StandardError do
+      ac.addBClasses :notabclass
+    end
+    
+    # remove the BClass from the AClass
+    ac.removeBClasses bc
+    assert !ac.bClasses.include?(bc)
+    assert !bc.aClasses.include?(ac)
+    
+    assert_equal [], AClassMM.ecore.eReferences.select{|r| r.many == false}
+    assert_equal  ["bClasses"], AClassMM.ecore.eReferences.select{|r| r.many == true}.name
+    assert_equal [], BClassMM.ecore.eReferences.select{|r| r.many == false}
+    assert_equal  ["aClasses"], BClassMM.ecore.eReferences.select{|r| r.many == true}.name
+  end
+  
+  class SomeSuperClass < RGen::MetamodelBuilder::MMBase
+    has_attr "name"
+    has_many "classAs", ClassA
+  end
+  
+  class SomeSubClass < SomeSuperClass
+    has_attr "subname"
+    has_many "classBs", ClassB
+  end
+  
+  class OtherSubClass < SomeSuperClass
+    has_attr "othersubname"
+    has_many "classCs", ClassC
+  end
+  
+  def test_inheritance
+    assert_equal ["name"], SomeSuperClass.ecore.eAllAttributes.name
+    assert_equal ["classAs"], SomeSuperClass.ecore.eAllReferences.name
+    assert_equal ["name", "subname"], SomeSubClass.ecore.eAllAttributes.name.sort
+    assert_equal ["classAs", "classBs"], SomeSubClass.ecore.eAllReferences.name.sort
+    assert_equal ["name", "othersubname"], OtherSubClass.ecore.eAllAttributes.name.sort
+    assert_equal ["classAs", "classCs"], OtherSubClass.ecore.eAllReferences.name.sort
+  end
+  
+  module AnnotatedModule 
+    extend RGen::MetamodelBuilder::ModuleExtension
 
-		assert_respond_to sc, :an_array
-		assert_respond_to sc, :an_array=
-		aa = Array.new
-		sc.an_array = aa
-		assert_equal aa, sc.an_array
-		
-		assert_raise StandardError do
-			sc.an_array = "a string"
-		end
-		
-		assert_equal HasOneTestClass.one_attributes, ["name", "an_array"]
-		assert_equal HasOneTestClass.many_attributes, []
-	end
-	
-	class HasManyTestClass < RGen::MetamodelBuilder::MMBase
-		has_many 'string', String
-	end
-	
-	def test_has_many
-		o = HasManyTestClass.new
-		o.addString("s1")
-		o.addString("s2")
-		assert_equal ["s1","s2"], o.string
-		# make sure we get a copy
-		o.string.clear
-		assert_equal ["s1","s2"], o.string
-		o.removeString("s3")
-		assert_equal ["s1","s2"], o.string
-		o.removeString("s2")
-		assert_equal ["s1"], o.string
-		assert_raise StandardError do
-			o.addString(:notastring)
-		end
-		assert_equal HasManyTestClass.one_attributes, []
-		assert_equal HasManyTestClass.many_attributes, ["string"]
-	end
+    annotation "moduletag" => "modulevalue"
+    
+    class AnnotatedClass < RGen::MetamodelBuilder::MMBase
+      annotation "sometag" => "somevalue", "othertag" => "othervalue"
+      annotation :source => "rgen/test", :details => {"thirdtag" => "thirdvalue"}
+    
+      has_attr "boolAttr", Boolean do
+        annotation "attrtag" => "attrval"
+        annotation :source => "rgen/test2", :details => {"attrtag2" => "attrvalue2", "attrtag3" => "attrvalue3"}
+      end
 
-	class OneClass < RGen::MetamodelBuilder::MMBase
-	end
-	class ManyClass < RGen::MetamodelBuilder::MMBase
-	end
-	OneClass.one_to_many 'manyClasses', ManyClass, 'oneClass'
-	
-	def test_one_to_many
-		oc = OneClass.new
-		assert_respond_to oc, :manyClasses
-		assert oc.manyClasses.empty?
-		
-		mc = ManyClass.new
-		assert_respond_to mc, :oneClass
-		assert_respond_to mc, :oneClass=
-		assert_nil mc.oneClass
-		
-		# put the OneClass into the ManyClass
-		mc.oneClass = oc
-		assert_equal oc, mc.oneClass
-		assert oc.manyClasses.include?(mc)
-		
-		# remove the OneClass from the ManyClass
-		mc.oneClass = nil
-		assert_equal nil, mc.oneClass
-		assert !oc.manyClasses.include?(mc)
+      has_many "others", AnnotatedClass do
+        annotation "reftag" => "refval"
+        annotation :source => "rgen/test3", :details => {"reftag2" => "refvalue2", "reftag3" => "refvalue3"}
+      end
 
-		# put the ManyClass into the OneClass
-		oc.addManyClasses mc
-		assert oc.manyClasses.include?(mc)
-		assert_equal oc, mc.oneClass
-		
-		# remove the ManyClass from the OneClass
-		oc.removeManyClasses mc
-		assert !oc.manyClasses.include?(mc)
-		assert_equal nil, mc.oneClass
+      many_to_many "m2m", AnnotatedClass, "m2mback" do
+        annotation "m2mtag" => "m2mval"
+        opposite_annotation "opposite_m2mtag" => "opposite_m2mval"
+      end
+    end
+    
+  end
+  
+  def test_annotations
+    assert_equal 1, AnnotatedModule.ecore.eAnnotations.size
+    anno = AnnotatedModule.ecore.eAnnotations.first
+    checkAnnotation(anno, nil, {"moduletag" => "modulevalue"})
 
-		assert_equal OneClass.one_attributes, []
-		assert_equal OneClass.many_attributes, ["manyClasses"]
-		assert_equal ManyClass.one_attributes, ["oneClass"]
-		assert_equal ManyClass.many_attributes, []
-	end
+    eClass = AnnotatedModule::AnnotatedClass.ecore
+    assert_equal 2, eClass.eAnnotations.size
+    anno = eClass.eAnnotations.find{|a| a.source == "rgen/test"}
+    checkAnnotation(anno, "rgen/test", {"thirdtag" => "thirdvalue"})
+    anno = eClass.eAnnotations.find{|a| a.source == nil}
+    checkAnnotation(anno, nil, {"sometag" => "somevalue", "othertag" => "othervalue"})
 
-	class OneClass2 < RGen::MetamodelBuilder::MMBase
-	end
-	class ManyClass2 < RGen::MetamodelBuilder::MMBase
-	end
-	ManyClass2.many_to_one 'oneClass', OneClass2, 'manyClasses'
-	
-	def test_one_to_many2
-		oc = OneClass2.new
-		assert_respond_to oc, :manyClasses
-		assert oc.manyClasses.empty?
-		
-		mc = ManyClass2.new
-		assert_respond_to mc, :oneClass
-		assert_respond_to mc, :oneClass=
-		assert_nil mc.oneClass
-		
-		# put the OneClass into the ManyClass
-		mc.oneClass = oc
-		assert_equal oc, mc.oneClass
-		assert oc.manyClasses.include?(mc)
-		
-		# remove the OneClass from the ManyClass
-		mc.oneClass = nil
-		assert_equal nil, mc.oneClass
-		assert !oc.manyClasses.include?(mc)
+    eAttr = eClass.eAttributes.first
+    assert_equal 2, eAttr.eAnnotations.size
+    anno = eAttr.eAnnotations.find{|a| a.source == "rgen/test2"}
+    checkAnnotation(anno, "rgen/test2", {"attrtag2" => "attrvalue2", "attrtag3" => "attrvalue3"})
+    anno = eAttr.eAnnotations.find{|a| a.source == nil}
+    checkAnnotation(anno, nil, {"attrtag" => "attrval"})
 
-		# put the ManyClass into the OneClass
-		oc.addManyClasses mc
-		assert oc.manyClasses.include?(mc)
-		assert_equal oc, mc.oneClass
-		
-		# remove the ManyClass from the OneClass
-		oc.removeManyClasses mc
-		assert !oc.manyClasses.include?(mc)
-		assert_equal nil, mc.oneClass
+    eRef = eClass.eReferences.find{|r| !r.eOpposite}
+    assert_equal 2, eRef.eAnnotations.size
+    anno = eRef.eAnnotations.find{|a| a.source == "rgen/test3"}
+    checkAnnotation(anno, "rgen/test3", {"reftag2" => "refvalue2", "reftag3" => "refvalue3"})
+    anno = eRef.eAnnotations.find{|a| a.source == nil}
+    checkAnnotation(anno, nil, {"reftag" => "refval"})
 
-		assert_equal OneClass2.one_attributes, []
-		assert_equal OneClass2.many_attributes, ["manyClasses"]
-		assert_equal ManyClass2.one_attributes, ["oneClass"]
-		assert_equal ManyClass2.many_attributes, []
-	end
+    eRef = eClass.eReferences.find{|r| r.eOpposite}
+    assert_equal 1, eRef.eAnnotations.size
+    anno = eRef.eAnnotations.first
+    checkAnnotation(anno, nil, {"m2mtag" => "m2mval"})
+    eRef = eRef.eOpposite
+    assert_equal 1, eRef.eAnnotations.size
+    anno = eRef.eAnnotations.first
+    checkAnnotation(anno, nil, {"opposite_m2mtag" => "opposite_m2mval"})
+  end
 
-	class AClassOO < RGen::MetamodelBuilder::MMBase
-	end
-	class BClassOO < RGen::MetamodelBuilder::MMBase
-	end
-	AClassOO.one_to_one 'bClass', BClassOO, 'aClass'
-
-	def test_one_to_one
-		ac = AClassOO.new
-		assert_respond_to ac, :bClass
-		assert_respond_to ac, :bClass=
-		assert_nil ac.bClass
-		
-		bc = BClassOO.new
-		assert_respond_to bc, :aClass
-		assert_respond_to bc, :aClass=
-		assert_nil bc.aClass
-		
-		# put the AClass into the BClass
-		bc.aClass = ac
-		assert_equal ac, bc.aClass
-		assert_equal bc, ac.bClass
-		
-		# remove the AClass from the BClass
-		bc.aClass = nil
-		assert_equal nil, bc.aClass
-		assert_equal nil, ac.bClass
-
-		# put the BClass into the AClass
-		ac.bClass = bc
-		assert_equal bc, ac.bClass
-		assert_equal ac, bc.aClass
-		
-		# remove the BClass from the AClass
-		ac.bClass = nil
-		assert_equal nil, ac.bClass
-		assert_equal nil, bc.aClass
-
-		assert_equal AClassOO.one_attributes, ["bClass"]
-		assert_equal AClassOO.many_attributes, []
-		assert_equal BClassOO.one_attributes, ["aClass"]
-		assert_equal BClassOO.many_attributes, []
-	end
-
-	class AClassMM < RGen::MetamodelBuilder::MMBase
-	end
-	class BClassMM < RGen::MetamodelBuilder::MMBase
-	end
-	AClassMM.many_to_many 'bClasses', BClassMM, 'aClasses'
-
-	def test_many_to_many
-	
-		ac = AClassMM.new
-		assert_respond_to ac, :bClasses
-		assert ac.bClasses.empty?
-
-		bc = BClassMM.new
-		assert_respond_to bc, :aClasses
-		assert bc.aClasses.empty?
-		
-		# put the AClass into the BClass
-		bc.addAClasses ac
-		assert bc.aClasses.include?(ac)
-		assert ac.bClasses.include?(bc)
-		
-		# put something else into the BClass
-		assert_raise StandardError do
-			bc.addAClasses :notaaclass
-		end
-		
-		# remove the AClass from the BClass
-		bc.removeAClasses ac
-		assert !bc.aClasses.include?(ac)
-		assert !ac.bClasses.include?(bc)
-
-		# put the BClass into the AClass
-		ac.addBClasses bc
-		assert ac.bClasses.include?(bc)
-		assert bc.aClasses.include?(ac)
-		
-		# put something else into the AClass
-		assert_raise StandardError do
-			ac.addBClasses :notabclass
-		end
-		
-		# remove the BClass from the AClass
-		ac.removeBClasses bc
-		assert !ac.bClasses.include?(bc)
-		assert !bc.aClasses.include?(ac)
-
-		assert_equal AClassMM.one_attributes, []
-		assert_equal AClassMM.many_attributes, ["bClasses"]
-		assert_equal BClassMM.one_attributes, []
-		assert_equal BClassMM.many_attributes, ["aClasses"]
-	end
-	
-	class SomeSuperClass < RGen::MetamodelBuilder::MMBase
-		has_one "name"
-		has_many "others"
-	end
-	
-	class SomeSubClass < SomeSuperClass
-		has_one "subname"
-		has_many "subothers"
-	end
-	
-	class OtherSubClass < SomeSuperClass
-		has_one "othersubname"
-		has_many "othersubothers"
-	end
-	
-	def test_inheritance
-		assert_equal SomeSuperClass.one_attributes, ["name"]
-		assert_equal SomeSuperClass.many_attributes, ["others"]
-		assert_equal SomeSubClass.one_attributes.sort, ["name", "subname"]
-		assert_equal SomeSubClass.many_attributes.sort, ["others", "subothers"]
-		assert_equal OtherSubClass.one_attributes.sort, ["name", "othersubname"]
-		assert_equal OtherSubClass.many_attributes.sort, ["others", "othersubothers"]
-	end
+  def checkAnnotation(anno, source, hash)
+    assert anno.is_a?(RGen::ECore::EAnnotation)
+    assert_equal source, anno.source
+    assert_equal hash.size, anno.details.size
+    hash.each_pair do |k, v|
+      detail = anno.details.find{|d| d.key == k}
+      assert detail.is_a?(RGen::ECore::EStringToStringMapEntry)
+      assert_equal v, detail.value
+    end
+  end
+  
 end