Class: TransformerTest

Inherits:

Test::Unit::TestCase

• Object
• Test::Unit::TestCase
• TransformerTest

Includes:

RGen::Util::ModelComparator, Testmodel::ClassModelChecker

Defined in:

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

Defined Under Namespace

Classes: CopyTransformer, ModelAIn, ModelAOut, ModelBIn, ModelBOut, ModelCIn, ModelCOut, ModelIn, ModelInSub, ModelOut, MyTransformer, MyTransformer2

Constant Summary

MODEL_DIR =

File.join(File.dirname(__FILE__),"testmodel")

Instance Method Summary

• #test_copyTransformer ⇒ Object
• #test_transformer ⇒ Object
• #test_transformer_array ⇒ Object
• #test_transformer_chain ⇒ Object
• #test_transformer_conditional ⇒ Object
• #test_transformer_cyclic ⇒ Object
• #test_transformer_subclass ⇒ Object

Methods included from RGen::Util::ModelComparator

#_modelEqual_internal, #modelEqual?

Methods included from Testmodel::ClassModelChecker

#checkClassModel, #checkClassModelPartial

Instance Method Details

#test_copyTransformer ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 241

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

#test_transformer ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 103

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

#test_transformer_array ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 157

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

#test_transformer_chain ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 115

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

#test_transformer_conditional ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 198

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

#test_transformer_cyclic ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 173

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

#test_transformer_subclass ⇒ Object

# File 'lib/puppet/vendor/rgen/test/transformer_test.rb', line 148

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