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