puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/test/transformer_test.rb

@@ -1,254 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-$:.unshift File.join(File.dirname(__FILE__),"..","test")
-
-require 'test/unit'
-require 'rgen/transformer'
-require 'rgen/environment'
-require 'rgen/util/model_comparator'
-require 'metamodels/uml13_metamodel'
-require 'testmodel/class_model_checker'
-
-class TransformerTest < Test::Unit::TestCase
-
-	class ModelIn
-		attr_accessor :name
-	end
-
-	class ModelInSub < ModelIn
-	end
-	
-	class ModelAIn
-		attr_accessor :name
-		attr_accessor :modelB
-	end
-
-	class ModelBIn
-		attr_accessor :name
-		attr_accessor :modelA
-	end
-
-	class ModelCIn
-		attr_accessor :number
-	end
-	
-	class ModelOut
-		attr_accessor :name
-	end
-	
-	class ModelAOut
-		attr_accessor :name
-		attr_accessor :modelB
-	end
-	
-	class ModelBOut
-		attr_accessor :name
-		attr_accessor :modelA
-	end
-	
-	class ModelCOut
-		attr_accessor :number
-	end
-	
-	class MyTransformer < RGen::Transformer
-		attr_reader :modelInTrans_count
-		attr_reader :modelAInTrans_count
-		attr_reader :modelBInTrans_count
-		
-		transform ModelIn, :to => ModelOut do
-			# aribitrary ruby code may be placed before the hash creating the output element
-			@modelInTrans_count ||= 0; @modelInTrans_count += 1
-			{ :name => name }
-		end
-		
-		transform ModelAIn, :to => ModelAOut do
-			@modelAInTrans_count ||= 0; @modelAInTrans_count += 1
-			{ :name => name, :modelB => trans(modelB) }
-		end
-		
-		transform ModelBIn, :to => ModelBOut do
-			@modelBInTrans_count ||= 0; @modelBInTrans_count += 1
-			{ :name => name, :modelA => trans(modelA) }
-		end
-		
-		transform ModelCIn, :to => ModelCOut, :if => :largeNumber do
-			# a method can be called anywhere in a transformer block
-			{ :number => duplicateNumber }
-		end
-
-		transform ModelCIn, :to => ModelCOut, :if => :smallNumber do
-			{ :number => number / 2 }
-		end
-		
-		method :largeNumber do
-			number > 1000
-		end
-		
-		method :smallNumber do
-			number < 500
-		end
-		
-		method :duplicateNumber do
-			number * 2;
-		end
-		
-	end
-	
-	class MyTransformer2 < RGen::Transformer
-		# check that subclasses are independent (i.e. do not share the rules)
-		transform ModelIn, :to => ModelOut do
-			{ :name => name }
-		end
-	end	
-	
-	def test_transformer
-		from = ModelIn.new
-		from.name = "TestName"
-		env_out = RGen::Environment.new
-		t = MyTransformer.new(:env_in, env_out)
-		assert t.trans(from).is_a?(ModelOut)
-		assert_equal "TestName", t.trans(from).name
-		assert_equal 1, env_out.elements.size
-		assert_equal env_out.elements.first, t.trans(from)
-		assert_equal 1, t.modelInTrans_count
-	end
-  
-  def test_transformer_chain
-    from = ModelIn.new
-    from.name = "Test1"
-    from2 = ModelIn.new
-    from2.name = "Test2"
-    from3 = ModelIn.new
-    from3.name = "Test3"
-    env_out = RGen::Environment.new
-    elementMap = {}
-    t1 = MyTransformer.new(:env_in, env_out, elementMap)
-		assert t1.trans(from).is_a?(ModelOut)
-		assert_equal "Test1", t1.trans(from).name
-		assert_equal 1, t1.modelInTrans_count
-    # modifying the element map means that following calls of +trans+ will be affected
-    assert_equal( {from => t1.trans(from)}, elementMap )
-    elementMap.merge!({from2 => :dummy})
-    assert_equal :dummy, t1.trans(from2)
-    # second transformer based on the element map of the first
-    t2 = MyTransformer.new(:env_in, env_out, elementMap)
-    # second transformer returns same objects
-    assert_equal t1.trans(from).object_id, t2.trans(from).object_id
-    assert_equal :dummy, t2.trans(from2)
-    # and no transformer rule is evaluated at this point
-		assert_equal nil, t2.modelInTrans_count
-    # now transform a new object in second transformer
-		assert t2.trans(from3).is_a?(ModelOut)
-		assert_equal "Test3", t2.trans(from3).name
-		assert_equal 1, t2.modelInTrans_count
-    # the first transformer returns the same object without evaluation of a transformer rule
-    assert_equal t1.trans(from3).object_id, t2.trans(from3).object_id
-		assert_equal 1, t1.modelInTrans_count
-  end
-	
-	def test_transformer_subclass
-		from = ModelInSub.new
-		from.name = "TestName"
-		t = MyTransformer.new
-		assert t.trans(from).is_a?(ModelOut)
-		assert_equal "TestName", t.trans(from).name
-		assert_equal 1, t.modelInTrans_count
-	end
-	
-	def test_transformer_array
-		froms = [ModelIn.new, ModelIn.new]
-		froms[0].name = "M1"
-		froms[1].name = "M2"
-		env_out = RGen::Environment.new
-		t = MyTransformer.new(:env_in, env_out)
-		assert t.trans(froms).is_a?(Array)
-		assert t.trans(froms)[0].is_a?(ModelOut)
-		assert_equal "M1", t.trans(froms)[0].name
-		assert t.trans(froms)[1].is_a?(ModelOut)
-		assert_equal "M2", t.trans(froms)[1].name
-		assert_equal 2, env_out.elements.size
-		assert (t.trans(froms)-env_out.elements).empty?
-		assert_equal 2, t.modelInTrans_count
-	end
-	
-	def test_transformer_cyclic
-		# setup a cyclic dependency between fromA and fromB
-		fromA = ModelAIn.new
-		fromB = ModelBIn.new
-		fromA.modelB = fromB
-		fromA.name = "ModelA"
-		fromB.modelA = fromA
-		fromB.name = "ModelB"
-		env_out = RGen::Environment.new
-		t = MyTransformer.new(:env_in, env_out)
-		# check that trans resolves the cycle correctly (no endless loop)
-		# both elements, fromA and fromB will be transformed with the transformation
-		# of the first element, either fromA or fromB
-		assert t.trans(fromA).is_a?(ModelAOut)
-		assert_equal "ModelA", t.trans(fromA).name
-		assert t.trans(fromA).modelB.is_a?(ModelBOut)
-		assert_equal "ModelB", t.trans(fromA).modelB.name
-		assert_equal t.trans(fromA), t.trans(fromA).modelB.modelA
-		assert_equal t.trans(fromB), t.trans(fromA).modelB
-		assert_equal 2, env_out.elements.size
-		assert (env_out.elements - [t.trans(fromA), t.trans(fromB)]).empty?
-		assert_equal 1, t.modelAInTrans_count
-		assert_equal 1, t.modelBInTrans_count
-	end
-	
-	def test_transformer_conditional
-		froms = [ModelCIn.new, ModelCIn.new, ModelCIn.new]
-		froms[0].number = 100
-		froms[1].number = 1000
-		froms[2].number = 2000
-
-		env_out = RGen::Environment.new
-		t = MyTransformer.new(:env_in, env_out)
-
-		assert t.trans(froms).is_a?(Array)
-		assert_equal 2, t.trans(froms).size
-		
-		# this one matched the smallNumber rule
-		assert t.trans(froms[0]).is_a?(ModelCOut)
-		assert_equal 50, t.trans(froms[0]).number
-		
-		# this one did not match any rule
-		assert t.trans(froms[1]).nil?
-
-		# this one matched the largeNumber rule
-		assert t.trans(froms[2]).is_a?(ModelCOut)
-		assert_equal 4000, t.trans(froms[2]).number
-		
-		# elements in environment are the same as the ones returned
-		assert_equal 2, env_out.elements.size
-		assert (t.trans(froms)-env_out.elements).empty?
-	end
-	
-	class CopyTransformer < RGen::Transformer
-		include UML13
-		def transform
-			trans(:class => UML13::Package)
-		end
-		UML13.ecore.eClassifiers.each do |c|
-		  copy c.instanceClass 
-    end
-	end
-
-	MODEL_DIR = File.join(File.dirname(__FILE__),"testmodel")
-
-	include Testmodel::ClassModelChecker
-    include RGen::Util::ModelComparator
-	
-	def test_copyTransformer
-		envIn = RGen::Environment.new
-		envOut = RGen::Environment.new
-
-    EASupport.instantiateUML13FromXMI11(envIn, MODEL_DIR+"/ea_testmodel.xml") 
-		
-		CopyTransformer.new(envIn, envOut).transform
-		checkClassModel(envOut)
-		assert modelEqual?(
-		  envIn.find(:class => UML13::Model).first,
-		  envOut.find(:class => UML13::Model).first)
-	end
-	
-end

data/lib/puppet/vendor/rgen/test/util/file_cache_map_test.rb

@@ -1,99 +0,0 @@
-$:.unshift(File.dirname(__FILE__)+"/../../lib")
-
-require 'test/unit'
-require 'fileutils'
-require 'rgen/util/file_cache_map'
-
-class FileCacheMapTest < Test::Unit::TestCase
-
-  TestDir = File.dirname(__FILE__)+"/file_cache_map_test/testdir"
- 
-  def setup
-    FileUtils.rm_r(Dir[TestDir+"/*"])
-    # * doesn't include dot files
-    FileUtils.rm_r(Dir[TestDir+"/.cache"])
-    @cm = RGen::Util::FileCacheMap.new(".cache", ".test")
-  end
-   
-  def test_nocache
-    reasons = []
-    assert_equal(:invalid, @cm.load_data(TestDir+"/fileA", :invalidation_reasons => reasons))
-    assert_equal [:no_cachefile], reasons
-  end
-
-  def test_storeload
-    keyFile = TestDir+"/fileA"  
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.store_data(keyFile, "valuedata")
-    assert(File.exist?(TestDir+"/.cache/fileA.test"))
-    assert_equal("valuedata", @cm.load_data(keyFile))
-  end
-
-  def test_storeload_subdir
-    keyFile = TestDir+"/subdir/fileA"
-    FileUtils.mkdir(TestDir+"/subdir")
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.store_data(keyFile, "valuedata")
-    assert(File.exist?(TestDir+"/subdir/.cache/fileA.test"))
-    assert_equal("valuedata", @cm.load_data(keyFile))
-  end
-
-  def test_storeload_postfix
-    keyFile = TestDir+"/fileB.txt"  
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.store_data(keyFile, "valuedata")
-    assert(File.exist?(TestDir+"/.cache/fileB.txt.test"))
-    assert_equal("valuedata", @cm.load_data(keyFile))
-  end
-
-  def test_storeload_empty
-    keyFile = TestDir+"/fileA"  
-    File.open(keyFile, "w") {|f| f.write("")}
-    @cm.store_data(keyFile, "valuedata")
-    assert(File.exist?(TestDir+"/.cache/fileA.test"))
-    assert_equal("valuedata", @cm.load_data(keyFile))
-  end
-
-  def test_corruptcache
-    keyFile = TestDir+"/fileA"
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.store_data(keyFile, "valuedata")
-    File.open(TestDir+"/.cache/fileA.test","a") {|f| f.write("more data")}
-    reasons = []
-    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
-    assert_equal [:cachefile_corrupted], reasons
-  end  
-
-  def test_changedcontent
-    keyFile = TestDir+"/fileA"
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.store_data(keyFile, "valuedata")
-    File.open(keyFile, "a") {|f| f.write("more data")}
-    reasons = []
-    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
-    assert_equal [:keyfile_changed], reasons
-  end 
-
-  def test_versioninfo
-    keyFile = TestDir+"/fileA"  
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.version_info = "123"
-    @cm.store_data(keyFile, "valuedata")
-    assert(File.exist?(TestDir+"/.cache/fileA.test"))
-    assert_equal("valuedata", @cm.load_data(keyFile))
-  end
-
-  def test_changed_version
-    keyFile = TestDir+"/fileA"  
-    File.open(keyFile, "w") {|f| f.write("somedata")}
-    @cm.version_info = "123"
-    @cm.store_data(keyFile, "valuedata")
-    @cm.version_info = "456"
-    reasons = []
-    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
-    assert_equal [:keyfile_changed], reasons
-  end
-
-end
-
-

data/lib/puppet/vendor/rgen/test/util/pattern_matcher_test.rb

@@ -1,97 +0,0 @@
-$:.unshift(File.dirname(__FILE__)+"/../../lib")
-
-require 'test/unit'
-require 'rgen/environment'
-require 'rgen/metamodel_builder'
-require 'rgen/model_builder'
-require 'rgen/util/pattern_matcher'
-
-class PatternMatcherTest < Test::Unit::TestCase
-
-module TestMM
-  extend RGen::MetamodelBuilder::ModuleExtension
-
-  class Node < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-    contains_many 'children', Node, 'parent'
-  end
-end
-
-def modelA 
-  env = RGen::Environment.new
-  RGen::ModelBuilder.build(TestMM, env) do 
-    node "A" do
-      node "AA"
-    end
-    node "B" do
-      node "B1"
-      node "B2"
-      node "B3"
-    end
-    node "C" do
-      node "C1"
-      node "C2"
-    end
-    node "D" do
-      node "DD"
-    end
-  end
-  env
-end
-
-def test_simple
-  matcher = RGen::Util::PatternMatcher.new
-  matcher.add_pattern("simple") do |env, c|
-    TestMM::Node.new(:name => "A", :children => [
-      TestMM::Node.new(:name => "AA")])
-  end
-  matcher.add_pattern("bad") do |env, c|
-    TestMM::Node.new(:name => "X")
-  end
-  env = modelA
-
-  match = matcher.find_pattern(env, "simple")
-  assert_not_nil match
-  assert_equal "A", match.root.name
-  assert_equal env.find(:class => TestMM::Node, :name => "A").first.object_id, match.root.object_id
-  assert_equal 2, match.elements.size
-  assert_equal [nil], match.bound_values
-
-  assert_nil matcher.find_pattern(env, "bad")
-end
-
-def test_value_binding
-  matcher = RGen::Util::PatternMatcher.new
-  matcher.add_pattern("single_child") do |env, name, child|
-    TestMM::Node.new(:name => name, :children => [ child ])
-  end
-  matcher.add_pattern("double_child") do |env, name, child1, child2|
-    TestMM::Node.new(:name => name, :children => [ child1, child2 ])
-  end
-  matcher.add_pattern("child_pattern") do |env, child_name|
-    TestMM::Node.new(:name => "A", :children => [
-      TestMM::Node.new(:name => child_name)])
-  end
-  env = modelA
-
-  match = matcher.find_pattern(env, "single_child")
-  assert_not_nil match
-  assert_equal "A", match.root.name
-  assert_equal "AA", match.bound_values[1].name
-
-  match = matcher.find_pattern(env, "single_child", "D")
-  assert_not_nil match
-  assert_equal "D", match.root.name
-  assert_equal "DD", match.bound_values[0].name
-
-  match = matcher.find_pattern(env, "double_child")
-  assert_not_nil match
-  assert_equal "C", match.root.name
-
-  match = matcher.find_pattern(env, "child_pattern")
-  assert_not_nil match
-  assert_equal ["AA"], match.bound_values
-end
-
-end
-

data/lib/puppet/vendor/rgen/test/util_test.rb

@@ -1,5 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'util/file_cache_map_test'
-require 'util/pattern_matcher_test'
-

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_ecore_model_checker.rb

@@ -1,94 +0,0 @@
-require 'rgen/ecore/ecore'
-
-# This "light" version of the ECore model checker is used to check the
-# model produced by the XMLInstantiatorTest only. 
-# 
-module SimpleECoreModelChecker			
-  include RGen::ECore
-  
-  def checkECoreModel(env)
-    
-    # check main package
-    mainPackage = env.elements.select {|e| e.is_a? EPackage and e.name == "HouseMetamodel"}.first
-    assert_not_nil mainPackage
-    
-    # check Rooms package
-    assert mainPackage.eSubpackages.is_a?(Array)
-    assert_equal 1, mainPackage.eSubpackages.size
-    assert mainPackage.eSubpackages[0].is_a?(EPackage)
-    roomsPackage = mainPackage.eSubpackages[0]
-    assert_equal "Rooms", roomsPackage.name
-    
-    # check main package classes
-    assert mainPackage.eClassifiers.is_a?(Array)
-    assert_equal 3, mainPackage.eClassifiers.size
-    assert mainPackage.eClassifiers.all?{|c| c.is_a?(EClass)}
-    houseClass = mainPackage.eClassifiers.select{|c| c.name == "House"}.first
-    personClass = mainPackage.eClassifiers.select{|c| c.name == "Person"}.first
-    meetingPlaceClass = mainPackage.eClassifiers.select{|c| c.name == "MeetingPlace"}.first
-    assert_not_nil houseClass
-    assert_not_nil personClass
-    assert_not_nil meetingPlaceClass
-    
-    # check Rooms package classes
-    assert roomsPackage.eClassifiers.is_a?(Array)
-    assert_equal 3, roomsPackage.eClassifiers.size
-    assert roomsPackage.eClassifiers.all?{|c| c.is_a?(EClass)}
-    roomClass = roomsPackage.eClassifiers.select{|c| c.name == "Room"}.first
-    kitchenClass = roomsPackage.eClassifiers.select{|c| c.name == "Kitchen"}.first
-    bathroomClass = roomsPackage.eClassifiers.select{|c| c.name == "Bathroom"}.first
-    assert_not_nil roomClass
-    assert_not_nil kitchenClass
-    assert_not_nil bathroomClass
-    
-    # check Room inheritance
-    assert kitchenClass.eSuperTypes.is_a?(Array)
-    assert_equal 2, kitchenClass.eSuperTypes.size
-    assert_equal roomClass.object_id, kitchenClass.eSuperTypes.select{|c| c.name == "Room"}.first.object_id
-    assert_equal meetingPlaceClass.object_id, kitchenClass.eSuperTypes.select{|c| c.name == "MeetingPlace"}.first.object_id
-    assert bathroomClass.eSuperTypes.is_a?(Array)
-    assert_equal 1, bathroomClass.eSuperTypes.size
-    assert_equal roomClass.object_id, bathroomClass.eSuperTypes[0].object_id
-    
-    # check House-Room "part of" association
-    assert houseClass.eAllContainments.eType.is_a?(Array)
-    assert_equal 1, houseClass.eAllContainments.eType.size
-    roomRef = houseClass.eAllContainments.first
-    assert_equal roomClass.object_id, roomRef.eType.object_id
-    assert_equal "room", roomRef.name
-    assert_equal 1, roomRef.lowerBound
-    assert_equal(-1, roomRef.upperBound)
-    assert_not_nil roomRef.eOpposite
-    assert_equal houseClass.object_id, roomRef.eOpposite.eType.object_id
-    
-    partOfRefs = roomClass.eReferences.select{|r| r.eOpposite && r.eOpposite.containment}
-    assert_equal 1, partOfRefs.size
-    assert_equal houseClass.object_id, partOfRefs.first.eType.object_id
-    assert_equal "house", partOfRefs.first.name
-    assert_equal roomRef.object_id, partOfRefs.first.eOpposite.object_id
-    
-    # check House OUT associations
-    assert houseClass.eReferences.is_a?(Array)
-    assert_equal 3, houseClass.eReferences.size
-    bathRef = houseClass.eReferences.find {|e| e.name == "bathroom"}
-    kitchenRef = houseClass.eReferences.find {|e| e.name == "kitchen"}
-    roomRef = houseClass.eReferences.find {|e| e.name == "room"}
-    assert_not_nil bathRef
-    assert_nil bathRef.eOpposite
-    assert_not_nil kitchenRef
-    assert_not_nil roomRef
-    assert_equal 1, kitchenRef.lowerBound
-    assert_equal 1, kitchenRef.upperBound
-    assert_equal 1, roomRef.lowerBound
-    assert_equal(-1, roomRef.upperBound)
-    
-    # check House IN associations
-    houseInRefs = env.find(:class => EReference, :eType => houseClass)
-    assert_equal 3, houseInRefs.size
-    homeEnd = houseInRefs.find{|e| e.name == "home"}
-    assert_not_nil homeEnd
-    assert_equal 0, homeEnd.lowerBound
-    assert_equal(-1, homeEnd.upperBound)
-    
-  end
-end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_xmi_ecore_instantiator.rb

@@ -1,53 +0,0 @@
-require 'rgen/instantiator/default_xml_instantiator'
-require 'rgen/environment'
-require 'rgen/ecore/ecore'
-require 'xml_instantiator_test/simple_xmi_metamodel'
-
-# SimpleXMIECoreInstantiator demonstrates the usage of the DefaultXMLInstantiator.
-# It can be used to instantiate an ECore model from an XMI description
-# produced by Enterprise Architect.
-# 
-# Note however, that this is *not* the recommended way to read an EA model.
-# See EAInstantiatorTest for the clean way to do this.
-# 
-# This example shows how arbitrary XML content can be used to instantiate
-# an implicit metamodel. The resulting model is transformed into a simple
-# ECore model.
-# 
-# See XMLInstantiatorTest for an example of how to use this class.
-# 
-class SimpleXMIECoreInstantiator < RGen::Instantiator::DefaultXMLInstantiator
-  
-  map_tag_ns "omg.org/UML1.3", SimpleXMIMetaModel::UML
-  
-  resolve_by_id :typeClass, :src => :type, :id => :xmi_id
-  resolve_by_id :subtypeClass, :src => :subtype, :id => :xmi_id
-  resolve_by_id :supertypeClass, :src => :supertype, :id => :xmi_id
-  
-  def initialize
-    @envXMI = RGen::Environment.new 
-    super(@envXMI, SimpleXMIMetaModel, true)
-  end
-  
-  def new_object(node)
-    if node.tag == "EAStub"
-      class_name = saneClassName(node.attributes["UMLType"])
-      mod = XMIMetaModel::UML
-      build_on_error(NameError, :build_class, class_name, mod) do
-        mod.const_get(class_name).new
-      end	 
-    else
-      super
-    end
-  end	
-  
-  # This method does the actual work.
-  def instantiateECoreModel(envOut, str)
-    instantiate(str)
-    
-    require 'xml_instantiator_test/simple_xmi_to_ecore'
-    
-    SimpleXmiToECore.new(@envXMI,envOut).transform
-  end
-  
-end

data/lib/puppet/vendor/rgen/test/xml_instantiator_test/simple_xmi_metamodel.rb

@@ -1,49 +0,0 @@
-# This is an extension of the implicit metamodel created by the
-# DefaultXMLInstantiator when it reads an Enterprise Architect
-# XMI file.
-# 
-module SimpleXMIMetaModel
-  
-  module UML
-    include RGen::MetamodelBuilder
-
-    class Classifier_feature < MMBase
-    end
-
-    class ClassifierRole < MMBase
-    end
-
-    class Clazz < ClassifierRole
-    end
-
-    class Interface < ClassifierRole
-    end
-
-    class Operation < MMBase
-    end
-
-    class Generalization < MMBase
-    end
-
-    class ModelElement_stereotype < MMBase
-    end
-
-    class AssociationEnd < MMBase
-      module ClassModule
-        def otherEnd
-          parent.associationEnd.find{|ae| ae != self}
-        end
-      end
-    end
-
-    class AssociationEndRole < MMBase
-    end
-
-    ClassifierRole.one_to_many 'associationEnds', AssociationEnd, 'typeClass'
-    ClassifierRole.one_to_many 'associationEndRoles', AssociationEndRole, 'typeClass'
-    Clazz.one_to_many 'generalizationsAsSubtype', Generalization, 'subtypeClass'
-    Clazz.one_to_many 'generalizationsAsSupertype', Generalization, 'supertypeClass'
-    
-  end
-  
-end