rgen 0.4.6 → 0.5.0

data/test/method_delegation_test.rb

@@ -0,0 +1,178 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'test/unit'
+require 'rgen/method_delegation'
+
+class MethodDelegationTest < Test::Unit::TestCase
+  include RGen
+  
+  class TestDelegate
+    attr_accessor :mode, :callcount
+    def common_delegated(delegator)
+      @callcount ||= 0
+      @callcount += 1
+      case @mode 
+        when :continue
+          throw :continue
+        when :delegatorId
+          delegator.object_id
+        when :return7
+          7
+      end
+    end
+    alias to_s_delegated common_delegated
+    alias methodInSingleton_delegated common_delegated
+    alias class_delegated common_delegated
+    alias artificialMethod_delegated common_delegated
+  end
+  
+  class ConstPathElement < Module
+    def self.const_missing_delegated(delegator, const)
+      ConstPathElement.new(const)
+    end
+    def initialize(name, parent=nil)
+      @name = name.to_s
+      @parent = parent
+    end
+    def const_missing(const)
+      ConstPathElement.new(const, self)
+    end
+    def to_s
+      if @parent
+        @parent.to_s+"::"+@name
+      else
+        @name
+      end
+    end
+  end
+  
+  # missing: check with multiple params and block param
+  
+  def test_method_defined_in_singleton
+    # delegator is an Array
+    delegator = []
+    # delegating method is a method defined in the singleton class
+    class << delegator
+      def methodInSingleton
+        "result from method in singleton"
+      end
+    end
+    checkDelegation(delegator, "methodInSingleton", "result from method in singleton")
+  end
+  
+  def test_method_defined_in_class
+    # delegator is a String
+    delegator = "Delegator1"
+    checkDelegation(delegator, "to_s", "Delegator1")
+  end
+  
+  def test_method_defined_in_superclass
+    # delegator is an instance of a new anonymous class
+    delegator = Class.new.new
+    # delegating method is +object_id+ which is defined in the superclass
+    checkDelegation(delegator, "class", delegator.class)
+  end
+  
+  def test_new_method
+    # delegator is an String
+    delegator = "Delegator2"
+    # delegating method is a new method which does not exist on String
+    checkDelegation(delegator, "artificialMethod", delegator.object_id, true)
+  end
+  
+  def test_const_missing
+    surroundingModule = Module.nesting.first
+    MethodDelegation.registerDelegate(ConstPathElement, surroundingModule, "const_missing")
+    
+    assert_equal "SomeArbitraryConst", SomeArbitraryConst.to_s
+    assert_equal "AnotherConst::A::B::C", AnotherConst::A::B::C.to_s
+    
+    MethodDelegation.unregisterDelegate(ConstPathElement, surroundingModule, "const_missing")
+    assert_raise NameError do 
+      SomeArbitraryConst
+    end
+  end
+  
+  def checkDelegation(delegator, method, originalResult, newMethod=false)
+    delegate1 = TestDelegate.new
+    delegate2 = TestDelegate.new
+    
+    MethodDelegation.registerDelegate(delegate1, delegator, method)
+    MethodDelegation.registerDelegate(delegate2, delegator, method)
+    
+    assert delegator.respond_to?(:_methodDelegates)
+    if newMethod
+      assert !delegator.respond_to?("#{method}_delegate_original".to_sym)
+    else
+      assert delegator.respond_to?("#{method}_delegate_original".to_sym)
+    end
+
+    # check delegator parameter    
+    delegate1.mode = :delegatorId
+    assert_equal delegator.object_id, delegator.send(method)
+    
+    delegate1.callcount = 0
+    delegate2.callcount = 0
+    
+    delegate1.mode = :return7
+    # delegate1 returns a value
+    assert_equal 7, delegator.send(method)
+    assert_equal 1, delegate1.callcount
+    # delegate2 is not called
+    assert_equal 0, delegate2.callcount
+    
+    delegate1.mode = :nothing
+    # delegate1 just exits and thus returns nil
+    assert_equal nil, delegator.send(method)
+    assert_equal 2, delegate1.callcount
+    # delegate2 is not called
+    assert_equal 0, delegate2.callcount
+    
+    delegate1.mode = :continue
+    delegate2.mode = :return7
+    # delegate1 is called but continues
+    # delegate2 returns a value
+    assert_equal 7, delegator.send(method)
+    assert_equal 3, delegate1.callcount
+    assert_equal 1, delegate2.callcount
+    
+    delegate1.mode = :continue
+    delegate2.mode = :continue
+    # both delegates continue, the original method returns its value
+    checkCallOriginal(delegator, method, originalResult, newMethod)
+    # both delegates are called though
+    assert_equal 4, delegate1.callcount
+    assert_equal 2, delegate2.callcount
+    
+    # calling unregister with a non existing method has no effect
+    MethodDelegation.unregisterDelegate(delegate1, delegator, "xxx")
+    MethodDelegation.unregisterDelegate(delegate1, delegator, method)
+    
+    checkCallOriginal(delegator, method, originalResult, newMethod)
+    # delegate1 not called any more
+    assert_equal 4, delegate1.callcount
+    # delegate2 is still called
+    assert_equal 3, delegate2.callcount
+    
+    MethodDelegation.unregisterDelegate(delegate2, delegator, method)
+    
+    checkCallOriginal(delegator, method, originalResult, newMethod)
+    # both delegates not called any more
+    assert_equal 4, delegate1.callcount
+    assert_equal 3, delegate2.callcount
+    
+    # after all delegates were unregistered, singleton class should be clean
+    assert !delegator.respond_to?(:_methodDelegates)
+  end  
+  
+  def checkCallOriginal(delegator, method, originalResult, newMethod)
+    if newMethod
+      assert_raise NoMethodError do
+        result = delegator.send(method)
+      end
+    else
+      result = delegator.send(method)
+      assert_equal originalResult, result
+    end
+  end
+end

data/test/model_builder/builder_context_test.rb

@@ -0,0 +1,59 @@
+$:.unshift File.dirname(__FILE__)+"/../lib"
+
+require 'test/unit'
+require 'rgen/ecore/ecore'
+require 'rgen/model_builder/builder_context'
+
+class BuilderContextTest < Test::Unit::TestCase
+  
+  module BuilderExtension1
+    module PackageA
+      def inPackAExt
+        3
+      end
+      module PackageB
+        def inPackBExt
+          5  
+        end
+      end
+    end
+  end
+  
+  class BuilderContext
+    def inBuilderContext
+      7
+    end
+  end
+  
+  def test_extensionContainerFactory
+    aboveRoot = RGen::ECore::EPackage.new(:name => "AboveRoot")
+    root = RGen::ECore::EPackage.new(:name => "Root", :eSuperPackage => aboveRoot)
+    packageA = RGen::ECore::EPackage.new(:name => "PackageA", :eSuperPackage => root)
+    packageB = RGen::ECore::EPackage.new(:name => "PackageB", :eSuperPackage => packageA)
+    packageC = RGen::ECore::EPackage.new(:name => "PackageBC", :eSuperPackage => packageA)
+    
+    factory = RGen::ModelBuilder::BuilderContext::ExtensionContainerFactory.new(root, BuilderExtension1, BuilderContext.new)
+    
+    assert_equal BuilderExtension1::PackageA, factory.moduleForPackage(packageA)
+    
+    packAExt = factory.extensionContainer(packageA)
+    assert packAExt.respond_to?(:inPackAExt)
+    assert !packAExt.respond_to?(:inPackBExt)
+    assert_equal 3, packAExt.inPackAExt
+    assert_equal 7, packAExt.inBuilderContext
+    
+    assert_equal BuilderExtension1::PackageA::PackageB, factory.moduleForPackage(packageB)
+    
+    packBExt = factory.extensionContainer(packageB)
+    assert !packBExt.respond_to?(:inPackAExt)
+    assert packBExt.respond_to?(:inPackBExt)
+    assert_equal 5, packBExt.inPackBExt
+    assert_equal 7, packBExt.inBuilderContext
+    
+    assert_raise RuntimeError do
+      # aboveRoot is not contained within root
+      assert_nil factory.moduleForPackage(aboveRoot)
+    end
+    assert_nil factory.moduleForPackage(packageC)
+  end
+end

data/test/model_builder/builder_test.rb

@@ -0,0 +1,284 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'test/unit'
+require 'rgen/ecore/ecore'
+require 'rgen/ecore/ecore_builder_methods'
+require 'rgen/environment'
+require 'rgen/model_builder'
+
+class ModelBuilderTest < Test::Unit::TestCase
+  
+  # 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
+    
+  def test_statemachine
+    result = RGen::ModelBuilder.build(StatemachineMetamodel) do 
+      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
+    end
+    
+    assert result.is_a?(Array)
+    assert_equal 2, result.size
+    
+    sm1 = result[0]
+    assert sm1.is_a?(StatemachineMetamodel::Statemachine)
+    assert_equal "Airconditioner", sm1.name
+    
+    assert_equal 2, sm1.state.size
+    offState = sm1.state[0]
+    assert offState.is_a?(StatemachineMetamodel::State)
+    assert_equal "Off", offState.name
+    assert_equal :START, offState.kind
+    
+    onState = sm1.state[1]
+    assert onState.is_a?(StatemachineMetamodel::CompositeState)
+    assert_equal "On", onState.name
+    
+    assert_equal 2, onState.state.size
+    hState = onState.state[0]
+    assert hState.is_a?(StatemachineMetamodel::State)
+    assert_equal "Heating", hState.name
+    
+    cState = onState.state[1]
+    assert cState.is_a?(StatemachineMetamodel::State)
+    assert_equal "Cooling", cState.name
+    
+    assert_equal 1, hState.outgoingTransition.size
+    hOutTrans = hState.outgoingTransition[0]
+    assert hOutTrans.is_a?(StatemachineMetamodel::Transition)
+    assert_equal cState, hOutTrans.targetState
+    assert_equal sm1, hOutTrans.statemachine
+    
+    assert_equal 1, hState.incomingTransition.size
+    hInTrans = hState.incomingTransition[0]
+    assert hInTrans.is_a?(StatemachineMetamodel::Transition)
+    assert_equal cState, hInTrans.sourceState
+    assert_equal sm1, hInTrans.statemachine
+    
+    assert_equal 2, hInTrans.condition.size
+    assert hInTrans.condition[0].is_a?(StatemachineMetamodel::Condition::TimeCondition::TimeCondition)
+    assert_equal 100, hInTrans.condition[0].timeout
+    assert hInTrans.condition[1].is_a?(StatemachineMetamodel::Condition::TimeCondition::TimeCondition)
+    assert_equal 10, hInTrans.condition[1].timeout
+    
+    sm2 = result[1]
+    assert sm2.is_a?(StatemachineMetamodel::Statemachine)
+    assert_equal "AirconExtension", sm2.name
+    
+    assert_equal 1, sm2.state.size
+    sState = sm2.state[0]
+    assert sState.is_a?(StatemachineMetamodel::State)
+    assert_equal "StartState", sState.name
+    
+    assert_equal 1, sState.outgoingTransition.size
+    assert sState.outgoingTransition[0].is_a?(StatemachineMetamodel::Transition)
+    assert_equal offState, sState.outgoingTransition[0].targetState
+    assert_equal sm2, sState.outgoingTransition[0].statemachine
+  end
+  
+  def test_dynamic
+    numStates = 5
+    env = RGen::Environment.new
+    result = RGen::ModelBuilder.build(StatemachineMetamodel, env) do
+      sm = statemachine "SM#{numStates}" do
+        (1..numStates).each do |i|
+          state "State#{i}" do
+            transition :as => :outgoingTransition, :targetState => "State#{i < numStates ? i+1 : 1}",
+              :statemachine => sm
+          end
+        end
+      end
+    end
+    assert_equal 11, env.elements.size
+    assert_equal "SM5", result[0].name
+    state = result[0].state.first
+    assert_equal "State1", state.name
+    state = state.outgoingTransition.first.targetState
+    assert_equal "State2", state.name
+    state = state.outgoingTransition.first.targetState
+    assert_equal "State3", state.name
+    state = state.outgoingTransition.first.targetState
+    assert_equal "State4", state.name
+    state = state.outgoingTransition.first.targetState
+    assert_equal "State5", state.name
+    assert_equal result[0].state[0], state.outgoingTransition.first.targetState
+  end
+  
+  def test_multiref
+    result = RGen::ModelBuilder.build(StatemachineMetamodel) do
+      a = transition
+      transition "b"
+      transition "c"
+      state :outgoingTransition => [a, "b", "c"]
+    end    
+    
+    assert result[0].is_a?(StatemachineMetamodel::Transition)
+    assert result[1].is_a?(StatemachineMetamodel::Transition)
+    assert !result[1].respond_to?(:name)
+    assert result[2].is_a?(StatemachineMetamodel::Transition)
+    assert !result[2].respond_to?(:name)
+    state = result[3]
+    assert state.is_a?(StatemachineMetamodel::State)
+    assert_equal result[0], state.outgoingTransition[0]
+    assert_equal result[1], state.outgoingTransition[1]
+    assert_equal result[2], state.outgoingTransition[2]
+  end
+  
+  module TestMetamodel
+    extend RGen::MetamodelBuilder::ModuleExtension
+    
+    # these classes have no name
+    class TestA < RGen::MetamodelBuilder::MMBase
+    end
+    class TestB < RGen::MetamodelBuilder::MMBase
+    end
+    class TestC < RGen::MetamodelBuilder::MMBase
+    end
+    TestA.contains_many 'testB', TestB, 'testA'
+    TestC.has_one 'testB', TestB
+  end
+  
+  def test_helper_names
+    result = RGen::ModelBuilder.build(TestMetamodel) do
+      testA "_a" do
+        testB "_b"
+      end
+      testC :testB => "_a._b"
+    end
+    assert result[0].is_a?(TestMetamodel::TestA)
+    assert result[1].is_a?(TestMetamodel::TestC)
+    assert_equal result[0].testB[0], result[1].testB
+  end
+    
+  def test_ecore
+    result = RGen::ModelBuilder.build(RGen::ECore, nil, RGen::ECore::ECoreBuilderMethods) do
+      ePackage "TestPackage1" do
+        eClass "TestClass1" do
+          eAttribute "attr1", :eType => RGen::ECore::EString
+          eAttr "attr2", RGen::ECore::EInt
+          eBiRef "biRef1", "TestClass2", "testClass1"
+          contains_1toN 'testClass2', "TestClass2", "tc1Parent"
+        end
+        eClass "TestClass2" do
+          eRef "ref1", "TestClass1"
+        end
+      end
+    end
+    
+    assert result.is_a?(Array)
+    assert_equal 1, result.size
+    p1 = result.first
+    
+    assert p1.is_a?(RGen::ECore::EPackage)
+    assert_equal "TestPackage1", p1.name
+    
+    # TestClass1
+    class1 = p1.eClassifiers.find{|c| c.name == "TestClass1"}
+    assert_not_nil class1
+    assert class1.is_a?(RGen::ECore::EClass)
+    
+    # TestClass1.attr1
+    attr1 = class1.eAllAttributes.find{|a| a.name == "attr1"}
+    assert_not_nil attr1
+    assert_equal RGen::ECore::EString, attr1.eType
+    
+    # TestClass1.attr2
+    attr2 = class1.eAllAttributes.find{|a| a.name == "attr2"}
+    assert_not_nil attr2
+    assert_equal RGen::ECore::EInt, attr2.eType
+    
+    # TestClass2
+    class2 = p1.eClassifiers.find{|c| c.name == "TestClass2"}
+    assert_not_nil class2
+    assert class2.is_a?(RGen::ECore::EClass)
+
+    # TestClass2.ref1
+    ref1 = class2.eAllReferences.find{|a| a.name == "ref1"}
+    assert_not_nil ref1
+    assert_equal class1, ref1.eType
+
+    # TestClass1.biRef1
+    biRef1 = class1.eAllReferences.find{|r| r.name == "biRef1"}
+    assert_not_nil biRef1
+    assert_equal class2, biRef1.eType
+    biRef1Opp = class2.eAllReferences.find {|r| r.name == "testClass1"}
+    assert_not_nil biRef1Opp
+    assert_equal class1, biRef1Opp.eType
+    assert_equal biRef1Opp, biRef1.eOpposite
+    assert_equal biRef1, biRef1Opp.eOpposite
+    
+    # TestClass1.testClass2
+    tc2Ref = class1.eAllReferences.find{|r| r.name == "testClass2"}
+    assert_not_nil tc2Ref
+    assert_equal class2, tc2Ref.eType
+    assert  tc2Ref.containment
+    assert_equal -1, tc2Ref.upperBound
+    tc2RefOpp = class2.eAllReferences.find{|r| r.name == "tc1Parent"}
+    assert_not_nil tc2RefOpp
+    assert_equal class1, tc2RefOpp.eType
+    assert !tc2RefOpp.containment
+    assert_equal 1, tc2RefOpp.upperBound
+  end
+  
+end