puppet 4.10.0 → 5.0.0

data/lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb

@@ -1,156 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../lib"
-
-require 'test/unit'
-require 'rgen/metamodel_builder'
-require 'rgen/model_builder/reference_resolver'
-
-class ReferenceResolverTest < Test::Unit::TestCase
-
-  class ClassA < RGen::MetamodelBuilder::MMBase
-    has_attr "name"
-  end
-  
-  class ClassB < RGen::MetamodelBuilder::MMBase
-    has_attr "name"
-  end
-
-  class ClassC < RGen::MetamodelBuilder::MMBase
-    has_attr "name"
-  end
-
-  ClassA.contains_many 'childB', ClassB, 'parentA'
-  ClassB.contains_many 'childC', ClassC, 'parentB'
-  ClassA.has_one 'refC', ClassC
-  ClassB.has_one 'refC', ClassC
-  ClassC.has_many 'refCs', ClassC
-  ClassC.has_one 'refA', ClassA
-  ClassC.has_one 'refB', ClassB
-  
-  def testModel
-    a1 = ClassA.new(:name => "a1")
-    a2 = ClassA.new(:name => "a2")
-    b1 = ClassB.new(:name => "b1", :parentA => a1)
-    b2 = ClassB.new(:name => "b2", :parentA => a1)
-    c1 = ClassC.new(:name => "c1", :parentB => b1)
-    c2 = ClassC.new(:name => "c2", :parentB => b1)
-    c3 = ClassC.new(:name => "c3", :parentB => b1)
-    [a1, a2, b1, b2, c1, c2, c3]
-  end
-  
-  def setElementNames(resolver, elements)
-    elements.each do |e|
-      resolver.setElementName(e, e.name)
-    end
-  end
-  
-  def createJob(hash)
-    raise "Invalid arguments" unless \
-      hash.is_a?(Hash) && (hash.keys & [:receiver, :reference, :namespace, :string]).size == 4
-    RGen::ModelBuilder::ReferenceResolver::ResolverJob.new(
-      hash[:receiver], hash[:reference], hash[:namespace], hash[:string])
-  end
-  
-  def test_resolve_same_namespace
-    a1, a2, b1, b2, c1, c2, c3 = testModel    
-    
-    toplevelNamespace = [a1, a2]
-    resolver = RGen::ModelBuilder::ReferenceResolver.new
-    setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
-      :namespace => b1,
-      :string => "c1"))
-    resolver.addJob(createJob(
-      :receiver => b2,
-      :reference => ClassB.ecore.eReferences.find{|r| r.name == "refC"},
-      :namespace => a1,
-      :string => "b1.c1"))
-    resolver.addJob(createJob(
-      :receiver => a2,
-      :reference => ClassA.ecore.eReferences.find{|r| r.name == "refC"},
-      :namespace => nil,
-      :string => "a1.b1.c1"))
-    resolver.resolve(toplevelNamespace)
-    
-    assert_equal [c1], c2.refCs
-    assert_equal c1, b2.refC
-    assert_equal c1, a2.refC
-  end
-
-  def test_resolve_parent_namespace
-    a1, a2, b1, b2, c1, c2, c3 = testModel    
-    
-    toplevelNamespace = [a1, a2]
-    resolver = RGen::ModelBuilder::ReferenceResolver.new
-    setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refA"},
-      :namespace => b1,
-      :string => "a1"))
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refB"},
-      :namespace => b1,
-      :string => "b1"))
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
-      :namespace => b1,
-      :string => "b1.c1"))
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
-      :namespace => b1,
-      :string => "a1.b1.c3"))
-    resolver.resolve(toplevelNamespace)
-    
-    assert_equal a1, c2.refA
-    assert_equal b1, c2.refB
-    assert_equal [c1, c3], c2.refCs
-  end
-  
-  def test_resolve_faulty
-    a1, a2, b1, b2, c1, c2, c3 = testModel    
-    
-    toplevelNamespace = [a1, a2]
-    resolver = RGen::ModelBuilder::ReferenceResolver.new
-    setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
-      :namespace => b1,
-      :string => "b1.c5"))
-    assert_raise RGen::ModelBuilder::ReferenceResolver::ResolverException do
-      resolver.resolve(toplevelNamespace)
-    end
-  end
-      
-  def test_ambiguous_prefix
-    a = ClassA.new(:name => "name1")
-    b1 = ClassB.new(:name => "name1", :parentA => a)
-    b2 = ClassB.new(:name => "target", :parentA => a)
-    c1 = ClassC.new(:name => "name21", :parentB => b1)
-    c2 = ClassC.new(:name => "name22", :parentB => b1)
-    
-    toplevelNamespace = [a]
-    resolver = RGen::ModelBuilder::ReferenceResolver.new
-    setElementNames(resolver, [a, b1, b2, c1, c2])
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
-      :namespace => b1,
-      :string => "name1.name1.name21"))
-    resolver.addJob(createJob(
-      :receiver => c2,
-      :reference => ClassC.ecore.eReferences.find{|r| r.name == "refB"},
-      :namespace => b1,
-      :string => "name1.target"))
-    resolver.resolve(toplevelNamespace)
-    
-    assert_equal [c1], c2.refCs
-    assert_equal b2, c2.refB
-  end
-
-end

data/lib/puppet/vendor/rgen/test/model_builder/serializer_test.rb

@@ -1,94 +0,0 @@
-$:.unshift File.dirname(__FILE__) + "/../lib"
-
-require 'test/unit'
-require 'rgen/ecore/ecore'
-
-# The following would also influence other tests...
-#
-#module RGen::ECore
-#  class EGenericType < EObject
-#    contains_many_uni 'eTypeArguments', EGenericType
-#  end
-#  class ETypeParameter < ENamedElement
-#  end
-#  class EClassifier
-#    contains_many_uni 'eTypeParameters', ETypeParameter
-#  end
-#  class ETypedElement
-#    has_one 'eGenericType', EGenericType
-#  end
-#end
-#
-#RGen::ECore::ECoreInterface.clear_ecore_cache
-#RGen::ECore::EString.ePackage = RGen::ECore.ecore
-
-require 'rgen/environment'
-require 'rgen/model_builder/model_serializer'
-require 'rgen/instantiator/ecore_xml_instantiator'
-require 'rgen/model_builder'
-require 'model_builder/statemachine_metamodel'
-
-class ModelSerializerTest < Test::Unit::TestCase
-  def test_ecore_internal
-    File.open(File.dirname(__FILE__)+"/ecore_internal.rb","w") do |f|
-      serializer = RGen::ModelBuilder::ModelSerializer.new(f, RGen::ECore.ecore)
-      serializer.serialize(RGen::ECore.ecore)
-    end
-  end
-  
-  def test_roundtrip
-    model = %{\
-statemachine "Airconditioner" do
-  state "Off", :kind => :START
-  compositeState "On" do
-    state "Heating"
-    state "Cooling"
-    state "Dumm"
-  end
-  transition "_Transition1", :sourceState => "On.Cooling", :targetState => "On.Heating"
-  transition "_Transition2", :sourceState => "On.Heating", :targetState => "On.Cooling"
-end
-}
-    check_roundtrip(StatemachineMetamodel, model)
-  end
-  
-  module AmbiguousRoleMM
-    extend RGen::MetamodelBuilder::ModuleExtension
-    class A < RGen::MetamodelBuilder::MMBase
-    end
-    class B < RGen::MetamodelBuilder::MMBase
-    end
-    class C < B
-    end
-    A.contains_many 'role1', B, 'back1'
-    A.contains_many 'role2', B, 'back2'
-  end
-
-  def test_roundtrip_ambiguous_role
-    model = %{\
-a "_A1" do
-  b "_B1", :as => :role1
-  b "_B2", :as => :role2
-  c "_C1", :as => :role2
-end
-}
-    check_roundtrip(AmbiguousRoleMM, model)
-  end
-
-  private
-
-  def build_model(mm, model)
-    RGen::ModelBuilder.build(mm) do
-      eval(model)
-    end
-  end
-
-  def check_roundtrip(mm, model)
-    sm = build_model(mm, model)
-    f = StringIO.new
-    serializer = RGen::ModelBuilder::ModelSerializer.new(f, mm.ecore)
-    serializer.serialize(sm)
-    assert_equal model, f.string
-  end
-
-end

data/lib/puppet/vendor/rgen/test/model_builder/statemachine_metamodel.rb

@@ -1,42 +0,0 @@
-# a test metamodel used by the following tests
-module StatemachineMetamodel
-  extend RGen::MetamodelBuilder::ModuleExtension
-  
-  module Condition
-    extend RGen::MetamodelBuilder::ModuleExtension
-  
-    class Condition < RGen::MetamodelBuilder::MMBase
-    end
-  
-    module TimeCondition
-      extend RGen::MetamodelBuilder::ModuleExtension
-  
-      class TimeCondition < Condition
-        has_attr 'timeout', Integer
-      end
-    end
-  end
-  
-  class Statemachine < RGen::MetamodelBuilder::MMBase
-    has_attr 'name'
-  end
-  
-  class State < RGen::MetamodelBuilder::MMBase
-    has_attr 'name'
-    has_attr 'kind', RGen::MetamodelBuilder::DataTypes::Enum.new([:START])
-  end
-  
-  class CompositeState < State
-    has_attr 'name'
-    contains_many 'state', State, 'compositeState'
-  end
-  
-  class Transition < RGen::MetamodelBuilder::MMBase
-    many_to_one 'sourceState', State, 'outgoingTransition'
-    many_to_one 'targetState', State, 'incomingTransition'
-    has_many 'condition', Condition::Condition
-  end
-  
-  Statemachine.contains_many 'state', State, 'statemachine'
-  Statemachine.contains_many 'transition', Transition, 'statemachine'
-end

data/lib/puppet/vendor/rgen/test/model_builder/test_model/statemachine1.rb

@@ -1,23 +0,0 @@
-statemachine "Airconditioner" do
-  state "Off", :kind => :START
-  compositeState "On" do
-    state "Heating" do
-      transition :as => :outgoingTransition, :targetState => "Cooling",
-        :statemachine => "Airconditioner"
-    end
-    state "Cooling" do
-    end
-  end
-  transition :sourceState => "On.Cooling", :targetState => "On.Heating" do
-    _using Condition::TimeCondition do
-      timeCondition :as => :condition, :timeout => 100
-    end
-    Condition::TimeCondition.timeCondition :as => :condition, :timeout => 10
-  end
-end
-_using Condition do
-  statemachine "AirconExtension" do
-    s = state "StartState"
-    transition :sourceState => s, :targetState => "Airconditioner.Off"
-  end
-end

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

@@ -1,6 +0,0 @@
-$:.unshift File.dirname(__FILE__) + "/../lib"
-
-require 'model_builder/builder_test'
-require 'model_builder/serializer_test'
-require 'model_builder/builder_context_test'
-require 'model_builder/reference_resolver_test'

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

@@ -1,30 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/metamodel_builder'
-require 'rgen/fragment/model_fragment'
-
-class ModelFragmentTest < Test::Unit::TestCase
-
-module TestMetamodel
-  extend RGen::MetamodelBuilder::ModuleExtension
-
-  class SimpleClass < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-    contains_many 'subclass', SimpleClass, 'parent'
-  end
-end
-
-def test_elements
-  root = TestMetamodel::SimpleClass.new(:name => "parent",
-    :subclass => [TestMetamodel::SimpleClass.new(:name => "child")])
-  
-  frag = RGen::Fragment::ModelFragment.new("location")
-  frag.set_root_elements([root])
-
-  assert_equal 2, frag.elements.size
-end
-
-end
-
-

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

@@ -1,58 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/template_language/output_handler'
-
-class MetamodelBuilderTest < Test::Unit::TestCase
-	def test_direct_nl
-		h = RGen::TemplateLanguage::OutputHandler.new
-		h.mode = :direct
-		h << "Test"
-		h.ignoreNextNL
-		h << "\nContent"
-		assert_equal "TestContent", h.to_s
-	end
-	def test_direct_ws
-		h = RGen::TemplateLanguage::OutputHandler.new
-		h.mode = :direct
-		h << "Test"
-		h.ignoreNextWS
-		h << " \n       Content"
-		assert_equal "TestContent", h.to_s
-	end
-	def test_explicit_indent
-		h = RGen::TemplateLanguage::OutputHandler.new
-		h.mode = :explicit
-		h.indent = 1
-		h << "Start"
-		h << "   \n "
-		h << "Test"
-		h << "      \n   \n    Content"
-		assert_equal "   Start\n   Test\n   Content", h.to_s
-	end
-	def test_explicit_endswithws
-		h = RGen::TemplateLanguage::OutputHandler.new
-		h.mode = :explicit
-		h.indent = 1
-		h << "Start   \n\n"
-		assert_equal "   Start\n", h.to_s
-	end
-  def test_performance
-    h = RGen::TemplateLanguage::OutputHandler.new
-    h.mode = :explicit
-    h.indent = 1
-    line = (1..50).collect{|w| "someword"}.join(" ")+"\n"
-    # repeat more often to make performance differences visible
-    20.times do 
-      h << line
-    end
-  end
-	def test_indent_string
-		h = RGen::TemplateLanguage::OutputHandler.new(1, "\t", :explicit)
-		h << "Start"
-		h << "   \n "
-		h << "Test"
-		h << "      \n   \n    Content"
-		assert_equal "\tStart\n\tTest\n\tContent", h.to_s
-	end
-end

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

@@ -1,48 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/metamodel_builder'
-require 'rgen/serializer/qualified_name_provider'
-
-class QualifiedNameProviderTest < Test::Unit::TestCase
-
-  class AbstractTestNode < RGen::MetamodelBuilder::MMBase
-    contains_many 'children', AbstractTestNode, "parent"
-  end
-
-  class NamedNode < AbstractTestNode
-    has_attr 'n', String
-  end
-
-  class UnnamedNode < AbstractTestNode
-  end
-
-  def test_simple
-    root = NamedNode.new(:n => "root", :children => [
-      NamedNode.new(:n => "a", :children => [
-        NamedNode.new(:n => "a1")
-      ]),
-      UnnamedNode.new(:children => [
-        NamedNode.new(:n => "b1")
-      ])
-    ])
-
-    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
-
-    assert_equal "/root", qnp.identifier(root)
-    assert_equal "/root/a", qnp.identifier(root.children[0])
-    assert_equal "/root/a/a1", qnp.identifier(root.children[0].children[0])
-    assert_equal "/root", qnp.identifier(root.children[1])
-    assert_equal "/root/b1", qnp.identifier(root.children[1].children[0])
-  end
-
-  def test_unnamed_root
-    root = UnnamedNode.new
-
-    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
-
-    assert_equal "/", qnp.identifier(root)
-  end
-
-end
-

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

@@ -1,102 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/metamodel_builder'
-require 'rgen/instantiator/qualified_name_resolver'
-
-class QualifiedNameResolverTest < Test::Unit::TestCase
-
-  class TestNode < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-    has_one 'nextSibling', TestNode
-    contains_many 'children', TestNode, "parent"
-  end
-
-  class TestNode2 < RGen::MetamodelBuilder::MMBase
-    has_attr 'cname', String
-    has_one 'nextSibling', TestNode2
-    contains_many 'children', TestNode2, "parent"
-  end
-
-  class TestNode3 < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-    contains_one 'child', TestNode3, "parent"
-  end
-
-  def testModel
-    [TestNode.new(:name => "Root1", :children => [
-      TestNode.new(:name => "Sub11"),
-      TestNode.new(:name => "Sub12", :children => [
-        TestNode.new(:name => "Sub121")])]),
-     TestNode.new(:name => "Root2", :children => [
-      TestNode.new(:name => "Sub21", :children => [
-        TestNode.new(:name => "Sub211")])]),
-     TestNode.new(:name => "Root3"),
-     TestNode.new(:name => "Root3")
-     ]
-  end
-
-  def testModel2
-    [TestNode2.new(:cname => "Root1", :children => [
-      TestNode2.new(:cname => "Sub11")])]
-  end
-
-  def testModel3
-    [TestNode3.new(:name => "Root1", :child =>
-      TestNode3.new(:name => "Sub11", :child =>
-        TestNode3.new(:name => "Sub111")))]
-  end
-
-  def test_customNameAttribute
-    model = testModel2
-    res = RGen::Instantiator::QualifiedNameResolver.new(model, :nameAttribute => "cname")
-    assert_equal model[0], res.resolveIdentifier("/Root1")
-    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
-  end
-
-  def test_customSeparator
-    model = testModel
-    res = RGen::Instantiator::QualifiedNameResolver.new(model, :separator => "|")
-    assert_equal model[0], res.resolveIdentifier("|Root1")
-    assert_nil res.resolveIdentifier("/Root1")
-    assert_equal model[0].children[0], res.resolveIdentifier("|Root1|Sub11")
-  end
-
-  def test_noLeadingSeparator
-    model = testModel
-    res = RGen::Instantiator::QualifiedNameResolver.new(model, :leadingSeparator => false)
-    assert_equal model[0], res.resolveIdentifier("Root1")
-    assert_nil res.resolveIdentifier("/Root1")
-    assert_equal model[0].children[0], res.resolveIdentifier("Root1/Sub11")
-  end
-    
-	def test_resolve
-    model = testModel
-    res = RGen::Instantiator::QualifiedNameResolver.new(model)
-    assert_equal model[0], res.resolveIdentifier("/Root1")
-    # again
-    assert_equal model[0], res.resolveIdentifier("/Root1")
-    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
-    # again
-    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
-    assert_equal model[0].children[1], res.resolveIdentifier("/Root1/Sub12")
-    assert_equal model[0].children[1].children[0], res.resolveIdentifier("/Root1/Sub12/Sub121")
-    assert_equal model[1], res.resolveIdentifier("/Root2")
-    assert_equal model[1].children[0], res.resolveIdentifier("/Root2/Sub21")
-    assert_equal model[1].children[0].children[0], res.resolveIdentifier("/Root2/Sub21/Sub211")
-    # duplicate name yields two result elements
-    assert_equal [model[2], model[3]], res.resolveIdentifier("/Root3")
-    assert_equal nil, res.resolveIdentifier("/RootX")
-    assert_equal nil, res.resolveIdentifier("/Root1/SubX")
-  end
-
-  def test_oneChild
-    model = testModel3
-    res = RGen::Instantiator::QualifiedNameResolver.new(model)
-    assert_equal model[0], res.resolveIdentifier("/Root1")
-    assert_equal model[0].child, res.resolveIdentifier("/Root1/Sub11")
-    assert_equal model[0].child.child, res.resolveIdentifier("/Root1/Sub11/Sub111")
-  end
-
-end
-

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

@@ -1,117 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-
-require 'test/unit'
-require 'rgen/metamodel_builder'
-require 'rgen/instantiator/reference_resolver'
-
-class ReferenceResolverTest < Test::Unit::TestCase
-
-  class TestNode < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-    has_one 'other', TestNode
-    has_many 'others', TestNode
-  end
-
-  class TestNode2 < RGen::MetamodelBuilder::MMBase
-    has_attr 'name', String
-  end
-
-  def test_identifier_resolver
-    nodeA, nodeB, nodeC, unresolved_refs = create_model
-    resolver = RGen::Instantiator::ReferenceResolver.new(
-      :identifier_resolver => proc do |ident|
-        {:a => nodeA, :b => nodeB, :c => nodeC}[ident]
-      end)
-    urefs = resolver.resolve(unresolved_refs)
-    check_model(nodeA, nodeB, nodeC)
-    assert urefs.empty?
-  end
-
-  def test_add_identifier
-    nodeA, nodeB, nodeC, unresolved_refs = create_model
-    resolver = RGen::Instantiator::ReferenceResolver.new
-    resolver.add_identifier(:a, nodeA)
-    resolver.add_identifier(:b, nodeB)
-    resolver.add_identifier(:c, nodeC)
-    urefs = resolver.resolve(unresolved_refs)
-    check_model(nodeA, nodeB, nodeC)
-    assert urefs.empty?
-  end
-
-  def test_problems
-    nodeA, nodeB, nodeC, unresolved_refs = create_model
-    resolver = RGen::Instantiator::ReferenceResolver.new(
-      :identifier_resolver => proc do |ident|
-        {:a => [nodeA, nodeB], :c => nodeC}[ident]
-      end)
-    problems = []
-    urefs = resolver.resolve(unresolved_refs, :problems => problems)
-    assert_equal ["identifier b not found", "identifier a not uniq"], problems
-    assert_equal 2, urefs.size
-    assert urefs.all?{|ur| !ur.target_type_error}
-  end
-
-  def test_on_resolve_proc
-    nodeA, nodeB, nodeC, unresolved_refs = create_model
-    resolver = RGen::Instantiator::ReferenceResolver.new
-    resolver.add_identifier(:a, nodeA)
-    resolver.add_identifier(:b, nodeB)
-    resolver.add_identifier(:c, nodeC)
-    data = []
-    resolver.resolve(unresolved_refs, 
-      :on_resolve => proc {|ur, e| data << [ ur, e ]})
-    assert data[0][0].is_a?(RGen::Instantiator::ReferenceResolver::UnresolvedReference)
-    assert_equal nodeA, data[0][0].element 
-    assert_equal "other", data[0][0].feature_name 
-    assert_equal :b, data[0][0].proxy.targetIdentifier 
-    assert_equal nodeB, data[0][1]
-  end
-
-  def test_target_type_error
-    nodeA, nodeB, nodeC, unresolved_refs = create_model
-    resolver = RGen::Instantiator::ReferenceResolver.new(
-      :identifier_resolver => proc do |ident|
-        {:a => TestNode2.new, :b => TestNode2.new, :c => nodeC}[ident]
-      end)
-    problems = []
-    urefs = resolver.resolve(unresolved_refs, :problems => problems)
-    assert_equal 2, problems.size
-    assert problems[0] =~ /invalid target type .*TestNode2/
-    assert problems[1] =~ /invalid target type .*TestNode2/
-    assert_equal 2, urefs.uniq.size
-    assert urefs[0].target_type_error
-    assert urefs[1].target_type_error
-    assert urefs.any?{|ur| ur.proxy.object_id == nodeA.other.object_id}
-    assert urefs.any?{|ur| ur.proxy.object_id == nodeB.others[0].object_id}
-  end
-
-  private
-
-  def create_model
-    nodeA = TestNode.new(:name => "NodeA")
-    nodeB = TestNode.new(:name => "NodeB")
-    nodeC = TestNode.new(:name => "NodeC")
-    bProxy = RGen::MetamodelBuilder::MMProxy.new(:b) 
-    nodeA.other = bProxy 
-    aProxy = RGen::MetamodelBuilder::MMProxy.new(:a) 
-    cProxy = RGen::MetamodelBuilder::MMProxy.new(:c) 
-    nodeB.others = [aProxy, cProxy] 
-    unresolved_refs = [
-      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeA, "other", bProxy),
-      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeB, "others", aProxy),
-      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeB, "others", cProxy)
-    ]
-    return nodeA, nodeB, nodeC, unresolved_refs
-  end
-
-  def check_model(nodeA, nodeB, nodeC)
-    assert_equal nodeB, nodeA.other
-    assert_equal [], nodeA.others
-    assert_equal nil, nodeB.other
-    assert_equal [nodeA, nodeC], nodeB.others
-    assert_equal nil, nodeC.other
-    assert_equal [], nodeC.others
-  end
-
-end
-