ontomde-java 2.0.0

data/test/uml_test.rb

@@ -0,0 +1,1434 @@
+#require 'test/unit'
+require 'test/unit'
+require 'test/unit/ui/console/testrunner.rb'
+require 'ontomde-uml2'
+
+# cf: http://www.ruby-doc.org/core/classes/Test/Unit/Assertions.html#M006697
+
+
+
+UML_FILES=[]
+
+MODELER=Set.new
+
+module Modeler
+  MODELER_EA71=1
+  MODELER_RSM6=2
+  MODELER_OE60=3
+  MODELER_OE53=4
+  MODELER_UNKNOWN=-1
+  
+  def ns_EA71(msg)
+    if MODELER.include?(MODELER_EA71)
+      fail("Enteprise Architect 7.1 does not support this feature:\n#{msg}")
+    end
+  end
+  def ns_OE60(msg)
+    if MODELER.include?(MODELER_OE60)
+      fail("Objecteering 6.0 does not support this feature\n#{msg}")
+    end
+  end
+  def ns_OE53(msg)
+    if MODELER.include?(MODELER_OE60)
+      fail("Objecteering 5.3 does not support this feature\n#{msg}")
+    end
+  end
+  #not applicable
+  def na_OE60()
+    return MODELER.include?(MODELER_OE60)
+  end
+  def na_rsm6()
+    return MODELER.include?(MODELER_RSM6)
+  end
+  def na_EA71
+    return MODELER.include?(MODELER_EA71)
+  end
+  def is_EA71
+    return MODELER.include?(MODELER_EA71)
+  end
+end
+
+module TestDocumentation
+  def test_commentOnClass
+    checkComment(getCdt,/__DOC_CDT__/)
+  end
+  def test_commentOnInterface
+    checkComment(getI1,/__DOC_INTERFACE__/)
+  end
+  def test_commentOnProperty
+    checkComment(getAnIA,/__DOC_PROP__/)
+  end
+  def test_commentOnEnumProperty
+    checkComment(getCdtCoul,/__DOC_PROP_ENUM__/)
+  end
+  def test_commentOnEnum
+    checkComment(getCouleurs,/__DOC_ENUM__/)
+  end
+  def test_commentOnLiteral
+    ns_OE60("Modeler does not support comment on enumeration literal")
+    checkComment(getPique,/__DOC_LIT__/)
+  end
+  def test_parameterComment
+    checkComment(getAnIntParam,/__DOC_PARAM__/)
+  end
+  def testComponentComment
+    checkComment(getComponent,/__DOC_COMPONENT__/)
+  end
+  def test_usecaseComment
+    checkComment(getAUseCase,/__USECASE_DOCUMENTATION__/)
+  end
+  def test_statemachineComment
+    checkComment(getStateMachine,/__STATE_MACHINE_DOC__/)
+  end
+  def test_stateComment
+    checkComment(getState,/__STATE_DOC__/)
+  end
+  def test_stateTransitionComment
+    ns_EA71("comment on transition not available on model (althougth available on diagram)")
+    checkComment(getTransition,/__STATE_TRANSITION_DOC__/)
+  end
+  def test_stateRegionComment
+    ns_EA71("comment on region not available on model (althougth available on diagram)")
+    checkComment(getRegion,/__STATEMACHINE_REGION_DOC__/)
+  end
+  
+end
+
+module TestsEnumLit
+  def test_couleur_hasPique
+    enumHasLit(getCouleurs,getPique)
+  end
+  def test_couleur_hasCoeur
+    enumHasLit(getCouleurs,getCoeur)
+  end
+  def test_couleur_hasCarreau
+    enumHasLit(getCouleurs,getCarreau)
+  end
+  def test_couleur_hasTrefle
+    enumHasLit(getCouleurs,getTrefle)
+  end
+end
+module TestsStatic
+  def test_NotStaticPropertyEnum
+    checkNotStatic(getCdtCoul)
+  end
+  def test_notStaticProperty
+    checkNotStatic(getAnIA)
+  end
+  def test_staticProperty
+    checkStatic(getASIA)
+  end
+  def test_staticOperation
+    checkStatic(getStaticVoidOperation)
+  end
+  def test_notStaticConstructor
+    checkNotStatic(getCustomConstrutor)
+  end
+  def test_StaticEnumOperation
+    ns_OE60("Modeler does not support operation on enumeration")
+    checkStatic(getOEE)
+  end 
+end
+module TestUnique
+  def test_uniqueAssociation
+    checkNotUnique(getNonUniqueAssoc) 
+  end
+  def test_uniqueAttribute
+    checkUnique(find("a Unique Attribute",Cuml_Property))
+  end
+  def test_NonuniqueAttribute
+    checkNotUnique(find("a Non Unique Attribute",Cuml_Property))
+  end
+end
+
+module TestsDerived
+  def test_derivedAssociation
+    checkDerived(find("derivedA",Cuml_Property))
+  end
+  def test_notDerivedAssociation
+    checkNotDerived(getSortedA)
+    checkNotDerived(getAnIA)
+  end
+end
+
+module TestsOrdered
+  def test_NotOrderedProperty
+    checkNotOrdered(getAnIA)
+  end
+  def test_OrderedProperty
+    checkOrdered(getSortedA)
+  end
+  def test_OrderedReturnParameter
+    checkOrdered(getReturnParamList)
+  end
+  def test_notOrderedReturnParameter
+    checkNotOrdered(getReturnParamSet)
+  end 
+end
+module TestsReadOnly
+  def test_NotReadOnlyProperty
+    checkNotReadOnly(getSortedA)
+  end
+  def test_NotReadOnlyAssociation
+    checkNotReadOnly(getSortedA)
+  end
+  def test_ReadOnlyProperty
+    checkReadOnly(find("readOnlyT",Cuml_Property))
+  end
+end
+module TestsImplements
+  def test_cdt_implems_i1
+    hasImplements(getCdt,getI1)
+  end
+  def test_cdt_implems_i3
+    hasImplements(getCdt,getI3)
+  end
+  def test_ClassDoesNotImplement
+    hasNotImplements(getCdt,getI2)
+  end
+  def test_ComponentImplementsInterface
+    hasImplements(getComponent,getI2)
+  end
+  def test_ComponentDoesNotImplementsInterface
+    hasNotImplements(getComponent,getI1)
+  end
+end
+module TestsGeneralisation
+  def test_I3_I5_inheritance 
+    hasGeneralization(getI3,getI5)
+  end
+  def test_I1_I2_inheritance
+    hasGeneralization(getI1,getI2)
+  end
+  def test_I1_I4_inheritance
+    hasGeneralization(getI1,getI4)
+  end
+end
+module TestsOwnedMember
+  def test_P11_in_P1
+    hasOwnedMember(getP1,getP11)
+  end
+  def test_P11_not_in_P1
+    #testing that test is not always true
+    hasNotOwnedMember(getP11,getP1)
+  end
+  def test_Cdt_in_P1
+    hasOwnedMember(getP1,getCdt)
+  end
+  def test_I1_in_P1
+    hasOwnedMember(getP1,getI1)
+  end
+  def test_I2_in_P1
+    hasOwnedMember(getP1,getI2)
+  end
+  def test_I3_in_P1
+    hasOwnedMember(getP1,getI3)
+  end
+  def test_I4_in_P1
+    hasOwnedMember(getP1,getI4)
+  end
+  def test_I5_in_P1
+    hasOwnedMember(getP1,getI5)
+  end
+  def test_couleurs_in_P1
+    hasOwnedMember(getP1,getCouleurs)
+  end
+  def test_C2_in_P11
+    hasOwnedMember(getP11,getC2)
+  end
+  def test_Component_in_P1
+    hasOwnedMember(getP1,getComponent)
+  end
+end
+module TestsNested
+  def test_InnerClass
+    hasNestedClassifier(getCdt,getInnerClassInsideCdt)
+  end
+end
+
+module TestClassType
+  def test_checkType_Carreau
+    findEnforceType("Carreau",Cuml_EnumerationLiteral)
+  end
+  def test_checkType_ClassDeuxNxPkg
+    findEnforceType("ClassDeuxNxPkg",Cuml_Class)
+  end
+  def test_checkType_ClasseDeTest
+    findEnforceType("Classe De Test",Cuml_Class)
+  end
+  def test_checkType_Classe3
+    findEnforceType("Classe3",Cuml_Class)
+  end
+  def test_checkType_Coeur
+    findEnforceType("Coeur",Cuml_EnumerationLiteral)
+  end
+  def test_checkType_Couleurs
+    findEnforceType("Couleurs",Cuml_Enumeration)
+  end
+  def test_checkType_Create
+    caseSensitive=false
+    multipleOccurence=true
+    #findEnforceType("CreaTe",Cuml_Stereotype,multipleOccurence,caseSensitive)
+  end
+  def test_checkType_EmptyEnum
+    findEnforceType("EmptyEnum",Cuml_Enumeration)
+  end
+  def test_checkType_InnerClassInsideCdt
+    findEnforceType("InnerClassInsideCdt",Cuml_Class)
+  end
+  def test_checkType_Interface1
+    findEnforceType("Interface1",Cuml_Interface)
+  end
+  def test_checkType_Interface2
+    findEnforceType("Interface2",Cuml_Interface)
+  end
+  def test_checkType_Interface3
+    findEnforceType("Interface3",Cuml_Interface)
+  end
+  def test_checkType_Interface4
+    findEnforceType("Interface4",Cuml_Interface)
+  end
+  def test_checkType_Interface5
+    findEnforceType("Interface5",Cuml_Interface)
+  end
+  def test_checkType_OperationEmptyEnum
+    ns_OE60("Modeler does not support operation on enumeration")
+    findEnforceType("OperationEmptyEnum",Cuml_Operation)
+  end
+  def test_checkType_OperationOutOfSpaceEnum
+    ns_OE60("Modeler does not support operation on enumeration")
+    findEnforceType("OperationOutOfSpaceEnum",Cuml_Operation)
+  end
+  def test_checkType_OutOfSpaceEnum
+    findEnforceType("OutOfSpaceEnum",Cuml_Enumeration)
+  end
+  def test_checkType_OutOfSpaceEnumProperty
+    ns_OE60("Modeler does not support property on enumeration")
+    findEnforceType("OutOfSpaceEnumProperty",Cuml_Property)
+  end
+  def test_checkType_Pique
+    findEnforceType("Pique",Cuml_EnumerationLiteral)
+  end
+  def test_checkType_Trefle
+    findEnforceType("Trefle",Cuml_EnumerationLiteral)
+  end
+  def test_checkType_aPackageMethod
+    findEnforceType("a Package Method",Cuml_Operation)
+  end
+  def test_checkType_aPrivateMethod
+    findEnforceType("a Private Method",Cuml_Operation)
+  end
+  def test_checkType_aStaticIntAttribute
+    findEnforceType("a Static Int Attribute",Cuml_Property)
+  end
+  def test_checkType_aStaticVoidOperation
+    findEnforceType("a Static Void Operation",Cuml_Operation)
+  end
+  def test_checkType_aStringAttribute
+    findEnforceType("a String Attribute",Cuml_Property)
+  end
+  def test_checkType_aBinaryOperation
+    findEnforceType("aBinaryOperation",Cuml_Operation)
+  end
+  def test_checkType_aBooleanAttribute
+    findEnforceType("aBooleanAttribute",Cuml_Property)
+  end
+  def test_checkType_anIntAttribute
+    findEnforceType("an Int Attribute",Cuml_Property)
+  end
+  def test_checkType_anIntParam
+    findEnforceType("anIntParam",Cuml_Parameter)
+  end
+  def test_checkType_classWithEntityAuxiliaryStereotype
+    findEnforceType("classWithEntityAuxiliaryStereotype",Cuml_Class)
+  end
+  def test_checkType_classeabstraite
+    findEnforceType("classeabstraite",Cuml_Property)
+  end
+  def test_checkType_compositeElement
+    findEnforceType("compositeElement",Cuml_Property)
+  end
+  def test_checkType_compositeElementOne
+    findEnforceType("compositeElementOne",Cuml_Property)
+  end
+  def test_checkType_couleur
+    findEnforceType("couleur",Cuml_Property)
+  end
+  def test_checkType_couleurOneMany
+    findEnforceType("couleurOneMany",Cuml_Property)
+  end
+  def test_checkType_couleurZeroMany
+    findEnforceType("couleurZeroMany",Cuml_Property)
+  end
+  def test_checkType_couleurZeroOne
+    findEnforceType("couleurZeroOne",Cuml_Property)
+  end
+  def test_checkType_customConstructor
+    findEnforceType("customConstructor",Cuml_Operation)
+  end
+  def test_checkType_defaultConstructor
+    findEnforceType("defaultConstructor",Cuml_Operation)
+  end
+  def test_checkType_derivedA
+    findEnforceType("derivedA",Cuml_Property)
+  end
+  def test_checkType_interface5
+    findEnforceType("interface5",Cuml_Property)
+  end
+  def test_checkType_methodReturnSetOfClasse3
+    findEnforceType("methodReturnSetOfClasse3",Cuml_Operation)
+  end
+  def test_checkType_pack1
+    findEnforceType("pack1",Cuml_Package)
+  end
+  def test_checkType_pack11
+    findEnforceType("pack11",Cuml_Package)
+  end
+  def test_checkType_pack2
+    findEnforceType("pack2",Cuml_Package)
+  end
+  def test_checkType_roleB
+    findEnforceType("roleB",Cuml_Property)
+  end
+  def test_checkType_sortedA
+    findEnforceType("sortedA",Cuml_Property)
+  end
+  def test_checkType_uneStringDansInterface5
+    findEnforceType("uneStringDansInterface5",Cuml_Property)
+  end
+  def test_checkType_AbstractClass
+    findEnforceType("ClasseAbstraite",Cuml_Class)
+  end
+  def test_checkType_AbstractOperation
+    findEnforceType("methodeAbstraite",Cuml_Operation,true)
+  end
+end
+
+
+module RepositoryGetters
+  def getAUseCase
+    return find("a Use Case",Cuml_UseCase)
+  end
+  def getNonUniqueAssoc
+    return find("nonUnique",Cuml_Property)
+  end
+  def getCdtCoul
+    return find("couleur",Cuml_Property)
+  end
+  def  getClassAux
+    find("classWithEntityAuxiliaryStereotype",Cuml_Class)
+  end
+  def getCustomConstrutor
+    find("customConstructor",Cuml_Operation)
+  end
+  def getDefaultConstructor
+    find("defaultConstructor",Cuml_Operation)
+  end
+
+  # enums
+  def getCouleurs
+    return find("Couleurs",Cuml_Enumeration)
+  end
+  def getPique
+    return find("Pique",Cuml_EnumerationLiteral)
+  end
+  def getCoeur
+    return find("Coeur",Cuml_EnumerationLiteral)
+  end
+  def getCarreau
+    return find("Carreau",Cuml_EnumerationLiteral)
+  end
+  def getTrefle
+    return find("Trefle",Cuml_EnumerationLiteral)
+  end
+  def getASIA
+    return find("a Static Int Attribute",Cuml_Property)
+  end
+  def getAbstractClass
+    return find("ClasseAbstraite",Cuml_Class)
+  end
+  def getAbstractOperation
+    return find("abstractMethodOne",Cuml_Operation)
+  end
+  def getSortedA
+    find("sortedA",Cuml_Property)
+  end
+  def getStaticVoidOperation
+    return find("a Static Void Operation",Cuml_Operation)
+  end
+  def  getI1
+    return find("Interface1",Cuml_Interface)
+  end
+  def  getI2
+    return find("Interface2",Cuml_Interface)
+  end
+  def  getI3
+    return find("Interface3",Cuml_Interface)
+  end
+  def  getI4
+    return find("Interface4",Cuml_Interface)
+  end
+  def  getI5
+    return find("Interface5",Cuml_Interface)
+  end
+  def  getC2
+    return find("ClassDeuxNxPkg",Cuml_Class)
+  end
+  def getAnIA
+    return find("an Int Attribute",Cuml_Property)
+  end
+  def getOEE
+    find("OperationEmptyEnum",Cuml_Operation)
+  end
+  def getOOOSE
+    find("OperationOutOfSpaceEnum",Cuml_Operation)
+  end
+  def getOSEnum
+    find("OutOfSpaceEnum",Cuml_Enumeration)
+  end
+  def getEmptyEnum
+    find("EmptyEnum",Cuml_Enumeration)
+  end
+  def getInterface5Property
+    find("uneStringDansInterface5",Cuml_Property)
+  end
+  def getOutOfSpaceEnumProperty
+    ns_OE60("Modeler does not support property on enumeration")
+    find("OutOfSpaceEnumProperty",Cuml_Property)
+  end
+  def  getP1
+    return find("pack1",Cuml_Package)
+  end
+  def  getP2
+    return find("pack2",Cuml_Package)
+  end
+  def  getP11
+    return find("pack11",Cuml_Package)
+  end
+  def getInnerClassInsideCdt
+    find("InnerClassInsideCdt",Cuml_Class)
+  end
+  # Class De test
+  def  getCdt
+    return find("Classe De Test",Cuml_Class)
+  end
+  def getCompositeAssoc
+    find("compositeElement",Cuml_Property)
+  end
+  def getCompositeAssocOne
+    find("compositeElementOne",Cuml_Property)
+  end
+  def getClasseAbstraiteAssoc
+    find("classeabstraite",Cuml_Property)
+  end
+  def getInterface5Assoc
+    find("interface5",Cuml_Property)
+  end
+  def getAnIntParam
+    find("anIntParam",Cuml_Parameter)
+  end
+  def getCouleurZeroManyProp
+    find("couleurZeroMany",Cuml_Property)
+  end
+  def getCouleurZeroOneProp
+    find("couleurZeroOne",Cuml_Property)
+  end
+  def getCouleurOneManyProp
+    find("couleurOneMany",Cuml_Property)
+  end
+end
+
+module TestsHelpers
+  @@r=nil
+  def getModel
+    return @@r
+  end
+  def setup
+    return unless @@r.nil?
+    if(MODELER.empty?)      
+      puts "getting model name from command line parameter"
+      if(ARGVsaved.empty?)	
+        puts "Model file name expected on command line"
+        exit(1)
+      end
+      UML_FILES.clear
+      UML_FILES.concat(ARGVsaved)
+    end 
+
+    @@r=Crdf_Repository.new
+    @@r.loadUml2
+    UML_FILES.each { |src|
+      @@r.loadModelFromFile(src)
+    }
+  end
+  DIRECT=[
+    ['a Region','file:///model/EAID_SR000001_92E0_46c2_B688_D19D37190DC5'],
+    ['a Fork State', 'file:///model/EAID_7554D931_5A38_4115_9A94_09E7CF48AE7E'],
+    ['a Join State','file:///model/EAID_DA7E6223_183E_4a2b_92F9_8FB63A136470']
+  ] 
+
+  def findEvery(reqType)
+    r=Set.new
+    @@r.each_value { |v|
+      ok=false
+      reqType.each  {|t|
+        ok=true if v.kind_of?(t)
+      }
+      next unless ok
+      next if v.to_s.index("base$")==0 # hack for filtering out RSM profile elements
+      r.add(v)
+    }
+    assert(r.length>0,"No element typed #{reqType} found in model")
+    return r
+  end
+  
+  def find(str,reqType,caseSensitive=true)
+    find_base(str,reqType,false,false,caseSensitive)
+  end
+  def findEnforceType(str,reqType,multipleOccurenceIsOK=false,caseSensitive=true)
+    find_base(str,reqType,true,multipleOccurenceIsOK,caseSensitive)
+  end
+  def find_base(str,reqType,enforce_type=false,multipleOccurenceIsOK=false,caseSensitive=true)
+    ret=nil
+    DIRECT.each { |v|
+      next if v[0].to_s!=str
+      f=@@r[v[1]]
+      ret=f unless f.nil?
+    }
+    @@r.each_value { |v|
+      #next if (!reqType.nil?) && (reqType!=v.class)
+      next unless v.respond_to? :uml_name
+      next unless caseSensitive ? (v.uml_name.to_s==str) : str.casecmp(v.uml_name.to_s)
+      if ret.nil?
+        ret=v
+        next
+      end
+      fail("FOUND MULTIPLE ELEMENTS IN REPOSITORY FOR (class=#{reqType}) (uml_name='#{str}')") unless multipleOccurenceIsOK
+    }
+    sample=<<END
+sample for an interface:    
+<http://kb#_4jNV8GqYEduiOKqS5xMIhQ> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Interface> .
+
+sample for a class:
+<http://kb#_4jNV8GqYEduiOKqS5xMIhQ> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Class> .
+
+END
+    assert_not_nil(ret,"MISSING ELEMENT IN REPOSITORY (class=#{reqType}) (uml_name='#{str}'). \nThis error is either because element has not been created in source UML MODEL, because element is spelled differentcly, or because of a bug in export chain.\nPlease refer to reference UML model for comparison (Rational RSM file).")
+    assert_equal(reqType,ret.class,"Element #{str} found with bad type\n#{sample}") if enforce_type
+    return ret
+  end
+  
+  def checkStatic(a,isStatic=true)
+    assert(a.uml_isStatic? == isStatic,%{#{a.class} '#{a}' should #{isStatic ? "":"not"} be static"})
+  end
+  def checkNotStatic(a)
+    checkStatic(a,false)
+  end
+
+  def checkOrdered(a,ordered=true)
+    sample=<<END
+    
+SAMPLE:
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#name> "#{a.uml_name}" .
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#isOrdered> "#{ordered}" .
+END
+    assert(a.uml_isOrdered? == ordered,%{#{a.class} '#{a}' should #{ordered ? "":"not"} be ordered. #{sample}"})
+  end
+  def checkNotOrdered(a)
+    checkOrdered(a,false)
+  end  
+  
+  def checkUnique(a,ordered=true)
+    sample=<<END
+    
+SAMPLE:
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#name> "#{a.uml_name}" .
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#isUnique> "#{ordered}" .
+END
+    assert(a.uml_isUnique? == ordered,%{#{a.class} '#{a}' should #{ordered ? "":"not"} be unique (no duplicate in collection). #{sample}"})
+  end
+  def checkNotUnique(a)
+    checkUnique(a,false)
+  end  
+  
+ def checkReadOnly(a,ordered=true)
+    sample=<<END
+    
+SAMPLE:
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#name> "#{a.uml_name}" .
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#isReadOnly> "#{ordered}" .
+END
+    assert(a.uml_isReadOnly? == ordered,%{#{a.class} '#{a}' should #{ordered ? "":"not"} be readonly (no duplicate in collection). #{sample}"})
+  end
+  def checkNotReadOnly(a)
+    checkReadOnly(a,false)
+  end  
+  
+  def checkDerived(a,val=true)
+    assert(a.uml_isDerived? == val,%{#{a.class} '#{a}' should #{val ? "":"not"} be derived"})
+  end
+  def checkNotDerived(a)
+    checkDerived(a,false)
+  end  
+  
+  def checkIsComposite(assoc)
+    assert_not_nil(assoc.uml_aggregation_one0,"#{assoc}:#{assoc.class} uml_aggregation field is empty")
+    assert(assoc.uml_aggregation_one.isComposite?,"#{assoc}:#{assoc.class} should be a composition")
+  end
+  def checkIsAggregation(assoc)
+    assert_not_nil(assoc.uml_aggregation_one0,"#{assoc}:#{assoc.class} uml_aggregation field is empty")
+    assert(assoc.uml_aggregation_one.isShared?,"#{assoc}:#{assoc.class} should be an aggregation (shared)")
+  end
+  def checkIsAggregationKindNone(assoc)
+    assert_not_nil(assoc.uml_aggregation_one0,"#{assoc}:#{assoc.class} uml_aggregation field is empty")
+    assert(assoc.uml_aggregation_one.isNone?,"#{assoc}:#{assoc.class} should be a regulare  association taggregationKind none)(not shared, not an association)")
+  end
+  
+  def checkIsPublic(assoc)
+    assert_not_nil(assoc.uml_visibility_one0,"#{assoc}:#{assoc.class} uml_visibility field is empty")
+    assert(assoc.uml_visibility_one.isPublic? ,"#{assoc}:#{assoc.class} has wrong visibility)")
+  end
+  def checkIsPrivate(assoc)
+    assert_not_nil(assoc.uml_visibility_one0,"#{assoc}:#{assoc.class} uml_visibility field is empty")
+    assert(assoc.uml_visibility_one.isPrivate? ,"#{assoc}:#{assoc.class} has wrong visibility)")
+  end
+  def checkIsProtected(assoc)
+    assert_not_nil(assoc.uml_visibility_one0,"#{assoc}:#{assoc.class} uml_visibility field is empty")
+    assert(assoc.uml_visibility_one.isProtected? ,"#{assoc}:#{assoc.class} has wrong visibility)")
+  end
+  def checkIsPackage(assoc)
+    assert_not_nil(assoc.uml_visibility_one0,"#{assoc}:#{assoc.class} uml_visibility field is empty")
+    assert(assoc.uml_visibility_one.isPackage? ,"#{assoc}:#{assoc.class} has wrong visibility)")
+  end
+   
+  def checkAbstract(assoc)
+    assert(assoc.uml_isAbstract?,"#{assoc}:#{assoc.class} uml_isAbstract should be true")
+  end
+  def checkNotAbstract(assoc)
+    assert(!(assoc.uml_isAbstract?),"#{assoc}:#{assoc.class} uml_isAbstract should not be true")
+  end
+  def hasNotImplements(elt,interface)
+    hasImplements(elt,interface,false)
+  end
+  def hasImplements(elt,interface,has=true)
+    found=nil
+    elt.uml_implementation.each {|r|
+      next unless r.uml_supplier_one0==interface
+      found=r
+    }
+    
+    sample=<<END
+    
+<http://kb#_ERsh0Gr6Edq5PInRr6uhgA> <http://uml/2#implementation> <http://kb#_8XJuUH6bEdqmEp6K9GS6ZQ> .
+<http://kb#_8XJuUH6bEdqmEp6K9GS6ZQ> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Implementation> .
+<http://kb#_8XJuUH6bEdqmEp6K9GS6ZQ> <http://uml/2#supplier> <http://kb#_4iph8H6bEdqmEp6K9GS6ZQ> 
+END
+    
+    assert_not_nil(found,"#{elt.class} '#{elt}' should implement interface '#{interface}'") if has
+    assert_nil(found,"#{elt.class} '#{elt}' should not implement interface '#{interface}'") unless has
+  end
+
+  def hasGeneralization(elt,general)
+    sample=<<END
+<http://kb#_bbbbbbbbbbb> <http://uml/2#generalization> <http://kb#_aaaa> .
+
+<http://kb#_aaaa> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Generalization> .
+<http://kb#_aaaa> <http://uml/2#specific> <http://kb#_bbbbbbbbbbb> .
+<http://kb#_aaaa> <http://uml/2#general> <http://kb#cccccc> .
+END
+    
+    found=nil
+    elt.uml_generalization.each {|r|
+      next unless r.uml_general_one0==general
+      found=r
+    }
+    assert_not_nil(found,"#{elt.class} '#{elt}' should inherit from '#{general}' #{sample}")
+  end
+
+  def hasNotOwnedMember(owner,owned)
+    hasOwnedMember(owner,owned,false)
+  end
+  def hasOwnedMember(owner,owned,has=true)
+    found=owner.uml_ownedMember.include?(owned)
+    assert(found,"missing uml_ownedMember  #{owned} for #{owner.class} '#{owner}'") if has
+    assert(!found,"wrong uml_ownedMember  #{owned} for #{owner.class} '#{owner}'") unless has
+  end
+
+  def hasNotOwnedOperation(owner,owned)
+    hasOwnedOperation(owner,owned,false)
+  end
+  def hasOwnedOperation(owner,owned,has=true)
+    found=owner.uml_ownedOperation.include?(owned)
+    assert(found,"missing uml_ownedOperation  #{owned} for #{owner.class} '#{owner}'")  if has
+    assert(!found,"extraneous uml_ownedOperation  #{owned} for #{owner.class} '#{owner}'")  unless has
+  end
+  def hasNestedClassifier(owner,owned)
+    found=owner.uml_nestedClassifier.include?(owned)
+    assert(found,"missing uml_nestedClassifier  #{owned} for #{owner.class} '#{owner}'")
+  end
+
+  def hasOwnedAttribute(owner,owned)
+    found=owner.uml_ownedAttribute.include?(owned)
+    assert(found,"missing uml_ownedAttribute  #{owned} for #{owner.class} '#{owner}'")
+  end
+  def hasNotOwnedAttribute(owner,owned)
+    found=owner.uml_ownedAttribute.include?(owned)
+    assert(!found,"#{owned} property should not be in uml_ownedAttribute for class #{owner.class} '#{owner}'")
+  end
+
+  def hasStereotype(elt,stereotype)
+    sample=<<END
+
+SAMPLE NTRIPLE CODE:    
+<http://kb#_m563wGq0EdypcdFc0YdcPQ> <http://uml/2#appliedStereotype> <http://kb#eeee> .
+<http://kb#eeee> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Stereotype> .
+<http://kb#eeee> <http://uml/2#name> "Documentation" .
+
+Note: Stereotypes names are not case sensitive (Documentation == documentation)
+END
+    assert(elt.umlx_hasStereotype?(stereotype.to_s),"#{elt}:#{elt.class} is missing stereotype #{stereotype} #{sample}")
+    casesensitive=false
+    #find(stereotype.to_s,Cuml_Stereotype,casesensitive)
+  end
+  def enumHasLit(enum,lit)
+    assert(enum.uml_ownedLiteral.include?(lit),"Enum '#{enum}' should contain literal '#{lit}'")
+  end
+  def checkComment(a,regexp)
+    sample=<<END
+    
+SAMPLE NTRIPLE CODE:
+<http://kb#_4iph8H6bEdqmEp6K9GS6ZQ> <http://uml/2#ownedComment> <http://kb#_2hVSsAl_Ed2sVL6lpXUdDw> ."
+<http://kb#_2hVSsAl_Ed2sVL6lpXUdDw> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#Comment> .
+<http://kb#_2hVSsAl_Ed2sVL6lpXUdDw> <http://uml/2#body> "interface documentation\\r\\nkey for unit tests: __DOC_INTERFACE__" .
+END
+    x=""
+    a.uml_ownedComment.each {|c|
+      assert_equal(Cuml_Comment,c.class,"#{a}:#{a.class} has badly typed comment.#{sample}.\ndebug:\n  comment.uri=#{c.rdf_uri}\n  comment.type=#{c.class}\n  comment.to_s=>>>#{c.to_s}<<<<")
+      x=x+c.uml_body_one0+c.to_s
+    }
+    assert_match(regexp,x,%{element "#{a}":#{a.class} does not have expected comment : #{regexp.source}#{sample}})
+  end
+  def checkCardinalityUpper(elt,card)
+    checkCardinality(elt,true,card)
+  end
+  def checkCardinalityLower(elt,card)
+    checkCardinality(elt,false,card)
+  end
+  
+  
+  def checkCardinality(elt,upper,card)
+    sample=<<END  
+
+SAMPLES:
+<http://kb#_UMtX4WUPEdu7KJt1RylUMg> <http://uml/2#lowerValue> <http://kb#_UM3I4GUPEdu7KJt1RylUMg> .
+<http://kb#_UM3I4GUPEdu7KJt1RylUMg> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#LiteralInteger> .
+<http://kb#_UM3I4GUPEdu7KJt1RylUMg> <http://uml/2#value> "0" .
+
+<http://kb#_LmgcAGp-EduiOKqS5xMIhQ> <http://uml/2#upperValue> <http://kb#_4jNV8GqYEduiOKqS5xMIhQ> .
+<http://kb#_4jNV8GqYEduiOKqS5xMIhQ> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://uml/2#LiteralUnlimitedNatural> 
+<http://kb#_4jNV8GqYEduiOKqS5xMIhQ> <http://uml/2#value> "-1" .
+
+END
+    
+    
+    
+    x= upper ? elt.uml_upperValue : elt.uml_lowerValue
+    assert(!x.empty?, %{missing #{upper ? "upperValue" : "lowerValue"} =~ /#{card.source}/ for #{elt}:#{elt.class} #{sample}})
+    #assert_match
+    assert_match(card,x.to_s,"Bad cardinality for element #{elt}:#{elt.class} #{sample}")
+  end
+  def checkRaisedException(method,excep,neg=true)
+    found=nil
+    method.uml_raisedException.each { |r|
+      next if r!=excep      
+      assert(found.nil?,"Exception #{r}thrown multiple times by method #{method}")
+      found=r
+    }
+    assert(!found.nil?,"Method #{method.to_s} should throw exception #{excep.to_s}") if neg
+    assert(found.nil?,"Method #{method} should *NOT* throw exception #{excep}") unless neg
+  end
+  def checkNotRaisedException(method,excep)
+    checkRaisedException(method,excep,false)
+  end
+end
+
+module TestsOwnedOperation
+  def test_emptyEnum_hasOperation #TEST1
+    ns_OE60("Modeler does not support Operation on enumeration")
+    hasOwnedOperation(getEmptyEnum, getOEE)
+  end
+  def test_OutOfSpaceEnum_hasOperation
+    ns_OE60("Modeler does not support Operation on enumeration")
+    hasOwnedOperation(getOSEnum,getOOOSE)
+  end
+  def test_ComponentHasOperation
+    hasOwnedOperation(getComponent,find("aComponentOperation",Cuml_Operation))
+    hasNotOwnedOperation(getComponent,getOOOSE)
+  end
+end
+module TestsOwnedAttribute
+  def test_OutOfSpaceEnum_hasAttribute
+    ns_OE60("Modeler does not support property on enumeration")
+    hasOwnedAttribute(getOSEnum,getOutOfSpaceEnumProperty)
+  end  
+  def test_Interface_has_property
+    hasOwnedAttribute(getI5,getInterface5Property)
+  end
+  def test_ComponentHasAttribute
+    hasOwnedAttribute(getComponent,find("aComponentAttribute",Cuml_Property))
+    hasNotOwnedAttribute(getComponent,getInterface5Property)
+  end
+end
+
+module TestOwnedParameter
+  def test_OperationWithOneParameter
+    op=find("setAnInt",Cuml_Operation)
+    n="anIntParam"
+    found=nil
+    op.uml_ownedParameter.each {|p|
+      assert(found==nil,"Operation #{op} has more than one parameter")
+      found=p
+      
+      assert_equal(n, p.uml_name.to_s,"Operation #{op} should have a parameter named #{n}")    
+    }
+    assert(found!=nil,"Operation #{op} should have a parameter named #{n}")
+    
+  end
+  def test_OperationWithNoParameter_notEmpty
+    assert(!(find("setAnInt",Cuml_Operation).uml_ownedParameter.empty?),"method setAnInt should have parameter")
+  end
+  def test_OperationWithNoParameter_empty
+    assert(getDefaultConstructor.uml_ownedParameter.empty?,"method #{getDefaultConstructor} should not have any parameter")
+  end
+end
+module TestDirectionParameter
+  def test_ParameterDirectionKind_return
+    o=find("get A Boolean",Cuml_Operation)
+    p=o.umlx_returnResult_one0
+    #    (o.uml_ownedParameter+o.uml_returnResult).each {|r|
+    #      p=r
+    #    }
+    assert_not_nil(p,"operation #{o} has no parameter")
+    assert_not_nil(p.uml_direction_one0,"missing direction for parameter  #{p}")
+    assert(p.uml_direction_one.isReturn?,"wrong direction for parameter #{p} (in expected)")
+  end
+  def test_ParameterDirectionKind_in
+    p=find("OwnedParameter1",Cuml_Parameter)
+    assert_not_nil(p.uml_direction_one0,"missing direction for parameter  #{p}")
+    assert(p.uml_direction_one.isIn?,"wrong direction for parameter #{p} (in expected)")
+  end
+  def test_ParameterDirectionKind_out
+    
+  end
+  def test_ParameterDirectionKind_inout
+    
+  end
+end
+
+module TestsStereotypes 
+  #def test_stereotype_create
+  #  caseSensitive=false
+  #  find("CreaTe",Cuml_Stereotype,caseSensitive)
+  #end
+  def test_customConstructor_has_stereotype_create
+    hasStereotype(getCustomConstrutor,"Create")
+  end
+  def test_defaultConstructor_has_stereotype_create
+    hasStereotype(getDefaultConstructor,"CreaTe")
+  end
+  def test_Aux_has_stereotype_auxiliary
+    hasStereotype(getClassAux,"AuxiLiarY")
+  end
+  def test_pack1ShouldHaveStereotypeFramework
+    hasStereotype(find("pack1",Muml_Package),"frAMEwork")
+  end
+  def test_stereotypeOnSourceAssociation
+    hasStereotype(find("withQualifier",Cuml_Property),"tEsT")
+  end
+  def test_stereotypeOnTargetAssociation
+    hasStereotype(p=find("withQualifierBiNav",Cuml_Property),"teST")
+  end
+  
+end
+module TestAggregationKind
+  def test_compositeAssocIsComposition 
+    checkIsComposite(getCompositeAssoc)
+  end
+  def test_compositeAssocOneIsComposition
+    checkIsComposite(getCompositeAssocOne)
+  end
+  def test_isAggregation
+    checkIsAggregation(getClasseAbstraiteAssoc)
+  end
+  def test_isAggregationKindNone
+    checkIsAggregationKindNone(getInterface5Assoc)
+  end
+end
+
+module TestCardinality
+  MANY=/^\*|-1$/
+  ONE=/^1$/
+  ZERO=/^0$/
+  def test_cardinalityPropertyUpperMany
+    checkCardinalityUpper(getCouleurZeroManyProp,MANY)
+  end
+  def test_cardinalityPropertyUpperOne
+    checkCardinalityUpper(getCouleurZeroOneProp,ONE)
+  end
+  def test_cardinalityPropertyUpperCustom
+    p=find("roleB",Cuml_Property)
+    checkCardinalityUpper(p,/^890$/)
+  end
+  def test_cardinalityPropertyLowerZero
+    checkCardinalityLower(getCouleurZeroOneProp,ZERO)
+  end
+  def test_cardinalityPropertyLowerOne
+    checkCardinalityLower(getCouleurOneManyProp,ONE)
+  end
+  def test_cardinalityPropertyLowerCustom
+    p=find("roleB",Cuml_Property)
+    checkCardinalityLower(p,/^49$/)
+  end
+  def test_cardinalityReturnParameter1
+    checkCardinalityUpper(getReturnParamList,MANY)
+  end
+  def test_cardinalityReturnParameter2
+    checkCardinalityUpper(getReturnParamSet,MANY)
+  end
+  def test_cardinalityReturnParameterLowerOne
+    checkCardinalityLower(getReturnParamSet,ONE)
+  end
+  def test_cardinalityReturnParameterLowerZero
+    checkCardinalityLower(getReturnParamList,ZERO)
+  end
+  
+  def getReturnParamList
+    find("methodReturnListOfClasse3",Cuml_Operation).umlx_returnResult_one0
+  end
+  def getReturnParamSet
+    find("methodReturnSetOfClasse3",Cuml_Operation).umlx_returnResult_one0
+  end
+  def test_card_bidi_OneMony
+    # check that bidi associations are not mixed up
+    checkCardinalityUpper(find("bidi_c2_2_s",Cuml_Class),MANY)
+    #checkCardinalityLower(find("bidi_c2_2_s",Cuml_Class),ZERO)
+  end
+end
+
+module TestVisibility
+  def test_publicMethod
+    checkIsPublic(find("aBinaryOperation",Cuml_Operation))
+  end
+  def test_privateMethod
+    checkIsPrivate(find("a Private Method",Cuml_Operation))
+  end
+  def test_packageMethod
+    checkIsPackage(find("a Package Method",Cuml_Operation))
+  end
+end
+
+module TestReturnParameter
+  def test_hasReturnParameter
+    o=find("methodReturnSetOfClasse3",Cuml_Operation)
+    ret=o.umlx_returnResult_one0
+    assert_not_nil(ret,"missing return for #{o}:#{o.class}")
+    checkType(ret,find("Classe3",Cuml_Class))
+  end
+end
+
+module TestType
+  STRING=/^string$/i
+  INT=/^int|integer$/i
+  BOOLEAN=/^boolean$/i
+  def test_propertyWithTypeString
+    checkDatatype(find("a String Attribute",Cuml_Property),STRING )
+  end
+  def test_propertyWithTypeInt
+    checkDatatype(find("an Int Attribute",Cuml_Property),INT )
+  end
+  def test_propertyWithTypeBoolean
+    checkDatatype(find("aBooleanAttribute",Cuml_Property),BOOLEAN )
+  end
+  def test_propertyWithTypeEnum
+    checkType(getCdtCoul,getCouleurs)
+  end
+    
+  def checkDatatype(elt,reg)
+    t=elt.uml_type_one0
+    assert_not_nil(t,"#{elt}:#{elt.class} has no uml_type")
+    assert(t.kind_of?(Muml_DataType),"wrong class for uml_type for #{elt}:#{elt.class}")
+    assert_match(reg,t.to_s,"wrong  uml_type for #{elt}:#{elt.class}")
+  end
+  def checkType(elt,ty)
+    t=elt.uml_type_one0
+    assert_not_nil(t,"#{elt}:#{elt.class} has no uml_type")
+    #assert(t.kind_of?(Muml_Classifier),"wrong class for uml_type for #{elt}:#{elt.class}")
+    assert_equal(ty,t,"wrong  uml_type for #{elt}:#{elt.class}")
+  end
+end
+
+module TestThrows
+  def getMethodThrows2
+    return find("methodeThrowsMyExceptionAndMyException2",Muml_Operation)
+  end
+  def getMethodThrows1
+    return find("methodeThrowsMyException",Muml_Operation)
+  end
+  def getException1
+    return find("MyException",Muml_Class)
+  end
+  def getException2
+    return find("MyException2",Muml_Class)
+  end
+  
+  def test_MethodThrowsA1
+    checkRaisedException(getMethodThrows2,getException1)
+  end
+  def test_MethodThrowsA2
+    checkRaisedException(getMethodThrows2,getException2)
+  end
+  def test_MethodThrowB1
+    checkRaisedException(getMethodThrows1,getException1)
+  end
+  def test_MethodThrowB2
+    checkNotRaisedException(getMethodThrows1,getException2)
+  end
+  def test_MethodNoThrow
+    checkNotRaisedException(getStaticVoidOperation,getException1)
+  end
+end
+
+module TestAbstract
+  def test_classAbstract
+    checkAbstract(getAbstractClass)
+  end
+  def test_classNotAbstract
+    checkNotAbstract(getCdt)
+  end
+  def test_methodAbstract
+    checkAbstract(getAbstractOperation)
+  end
+  def test_methodNotAbstract
+    checkNotAbstract(getStaticVoidOperation)
+  end
+end
+
+#other test specific known element
+#This test serie check that repository contains no invalid element
+module TestEvery
+  def test_EveryTypedElementHasAType
+    err=""
+    i=0
+    findEvery( [Muml_Property,Muml_Parameter]).each {|t|
+      next unless t.uml_type.empty?
+      i=i+1
+      err=err+"#{i}: No uml_type found for element #{t.to_s}:#{t.class}\n"
+    }
+    assert(err.length==0,err)
+  end
+  def test_everyStereotypeHaveNames
+    err=""
+    i=0
+    fe=findEvery( [Muml_Stereotype])
+    fe.each {|t|
+      next unless t.uml_name.empty?
+      i=i+1
+      err=err+"#{i}: No uml_name found for element #{t.to_s}:#{t.class}\n"
+    }
+    assert(err.length==0,err)  
+    assert(fe.length>0,"Model should contain at least one element of type stereotype")    
+  end
+  
+end
+
+module TestBiNavigable
+  def test_bidi
+    src_c=getCdt
+    tgt_c=find("ClassDeuxNxPkg",Cuml_Class)
+    
+    src_p=find("bidi_c2_3_s",Cuml_Property)
+    tgt_p=find("bidi_cdt_3_s",Cuml_Property)
+    
+    hasOwnedAttribute(src_c,src_p)
+    hasOwnedAttribute(tgt_c,tgt_p)
+    
+    src_a=src_p.uml_association_one0
+    tgt_a=tgt_p.uml_association_one0
+    
+    assert_not_nil(src_a,"missing uml_association for property #{src_p.to_s}")
+    assert_not_nil(tgt_a,"missing uml_association for property #{tgt_p.to_s}")
+    
+    assert_equal(src_a,tgt_a, "both association end should link to the same association")
+    
+    assert(src_a.uml_memberEnd.include?(src_p),"association end should contain #{src_p} property")
+    assert(src_a.uml_memberEnd.include?(tgt_p),"association end should contain #{tgt_p} property") 
+  end
+  
+
+  
+  def test_not_bidi
+    src_c=getCdt
+    tgt_c=find("ClassA",Cuml_Class)
+    
+    tgt_p=find("classdetest_ro",Cuml_Property)
+    src_p=find("readOnlyT",Cuml_Property)
+    
+    hasOwnedAttribute(src_c,src_p)
+    hasNotOwnedAttribute(tgt_c,tgt_p) #non navigable property is not owned by class.
+    
+    src_a=src_p.uml_association_one0
+    tgt_a=tgt_p.uml_association_one0
+    
+    assert_not_nil(src_a,"missing uml_association for property #{src_p.to_s}")
+    assert_not_nil(tgt_a,"missing uml_association for property #{tgt_p.to_s}")
+    
+    assert_equal(src_a,tgt_a, "both association end should link to the same association")
+    
+    assert(src_a.uml_memberEnd.include?(src_p),"association end should contain #{src_p} property")
+    assert(src_a.uml_memberEnd.include?(tgt_p),"association end should contain #{tgt_p} property") 
+  end
+end
+
+module TestQualifier
+  def test_aQualifier1
+    findEnforceType("aQualifier1",Cuml_Property)
+  end
+  
+  def test_associationHasAQualifierOnSource
+    p=find("withQualifierMany",Cuml_Property)
+    q1=find("aQualifier1",Cuml_Property)
+    assert(p.uml_qualifier.include?(q1),"Property #{p} should have a qualifier name #{q1}")
+    assert(!q1.uml_type.empty?,"Qualifier #{q1} does not have a uml_type")
+  end
+  
+  def test_associationHasAQualifierOnTarget
+    p=find("withQualifierBiNav",Cuml_Property)
+    q1=find("aQualifier2",Cuml_Property)
+    assert(p.uml_qualifier.include?(q1),"Property #{p} should have a qualifier name #{q1}")
+    assert(!q1.uml_type.empty?,"Qualifier #{q1} does not have a uml_type")
+  end
+    
+end
+module TestModel
+  def test_pack1InAModel
+    p=find("pack1",Muml_Package)
+    m=p.umlx_owner_one
+    assert_not_nil(m,"Element #{p} has no owner")
+    assert(m.umlx_isARootNamespace? , "Element #{p} should be owned by a Model or package stereotypd root.")
+  end
+end
+
+module TestJavaSuite
+  def test_additionalForJavaSuite
+    w=find("withQualifier",Muml_Property)
+    assert(!w.uml_isDerived?,"#{w}:#{w.class} should not be derived")
+  end
+end
+
+module TestComponent
+  def getComponent
+    return find("aComponent",Cuml_Component)
+  end
+  def getComponent2
+    return find("aSecondComponent",Cuml_Component)
+  end
+  def test_componentIsHere
+    
+  end
+end
+module TestStateMachine
+  def getStateMachine
+    return find("a State Machine2",Cuml_StateMachine)
+  end
+  def test_checkType_StateMachine
+    findEnforceType("a State Machine",Cuml_StateMachine)
+  end
+  def test_checkType_State
+    findEnforceType("a State",Cuml_State)
+  end
+  def getState
+    find("a State",Cuml_State)
+  end
+  def test_checkType_CompositeState
+    findEnforceType("a Composite State",Cuml_State)
+  end
+  def test_checkType_StartState
+    checkPseudoState("a Start State",Cuml_PseudostateKind::Initial)
+  end
+  def test_checkType_StartState
+    findEnforceType("a Final State",Cuml_FinalState)
+  end
+  def test_checkType_DecisionState
+    checkPseudoState("a Decision State",Cuml_PseudostateKind::Choice)
+  end
+  def test_checkType_forkState
+    checkPseudoState("a Fork State",Cuml_PseudostateKind::Fork)
+  end
+  def test_checkType_joinState
+    ns_EA71("Join pseudo state not supported")
+    checkPseudoState("a Join State",Cuml_PseudostateKind::Join)
+  end
+  def test_checkType_transition
+    findEnforceType("from A Start State To a State",Cuml_Transition)
+  end
+  def getTransition
+    return find("from A Start State To a State",Cuml_Transition)
+  end
+  def getStateMachine
+    return find("a State Machine",Cuml_StateMachine)
+  end
+  def test_checkType_stateMachine
+    return findEnforceType("a State Machine",Cuml_StateMachine)
+  end
+  def test_transitionSource
+    assert(find("a Start State",nil)==getTransition.uml_source_one0,"Transition '#{getTransition}' should have uml_source == 'a Start State' instead of '#{getTransition.uml_source_one0}'")
+  end
+  def test_transitionTarget
+    assert(find("a State",nil)==getTransition.uml_target_one0,"Transition '#{getTransition}' should have uml_target == 'a State' instead of '#{getTransition.uml_target_one0}'")
+  end
+  def test_checkType_region
+    findEnforceType("a Region",Cuml_Region)
+  end
+  def getRegion
+    find("a Region",Cuml_Region)
+  end
+  def test_check_StateInRegion
+    assert(getRegion.uml_subvertex.include?(getState),"Region 'a Region' should include state 'a State' in its uml_subvertex")
+    assert(!getRegion.uml_subvertex.include?(getRegion),"test internal error")
+  end
+  def test_check_RegionInStateMachine
+    assert(getStateMachine.uml_region.include?(getRegion),"state Machine 'a State Machine' should include region 'a Region' in uml_region")
+    assert(!getStateMachine.uml_region.include?(getStateMachine),"test internal error")
+  end
+  
+  def test_check_StateMachineInPackage
+    assert(getP1.uml_ownedMember.include?(getStateMachine),"Package P1 should include state machine 'a State Machine' in uml_ownedElement")
+  end
+  
+  
+  def checkPseudoState(label,kind)
+    s=findEnforceType(label,Cuml_Pseudostate)
+    assert(kind==s.uml_kind_one0,"'#{s}' state should have uml_kind==#{kind} instead of #{s.uml_kind_one0}")
+    #<http://uml/2#pseudostateKind_choice>
+    #<http://uml/2#pseudostateKind_deepHistory>
+    #<http://uml/2#pseudostateKind_entryPoint
+    #<http://uml/2#pseudostateKind_exitPoint>
+    #<http://uml/2#pseudostateKind_fork>
+    #<http://uml/2#pseudostateKind_initial>
+    #<http://uml/2#pseudostateKind_join>
+    #<http://uml/2#pseudostateKind_junction>
+    #<http://uml/2#pseudostateKind_shallowHistory>
+    #<http://uml/2#pseudostateKind_terminate>
+  end
+  
+end
+
+module TestTemplate
+  def test_tpl
+    tpl=find("ClassWithParameter",Cuml_Class)
+    assert(!tpl.uml_ownedTemplateSignature.empty?,"class #{tpl} should contain a template signature")  
+      
+    found_pt=nil
+    tpl.uml_ownedTemplateSignature.each {|ts|
+      # Muml_TemplateSignature
+      ts.uml_ownedParameter.each { |tp|
+        #Muml_TemplateParameter
+        c=tp.uml_ownedParameteredElement_one
+        assert_nil(found_pt,"found more than one template parameter for #{tpl}")
+        found_pt=c
+      }
+    }
+    assert(!found_pt.nil?,"class #{tpl} is missing template parameter")
+    pt=find("T",Cuml_Class)
+    assert(found_pt==pt,"class #{tpl} template parameter expected to be #{pt}")
+    param=find("paramTPL",Cuml_Parameter)
+    assert(!param.uml_type.empty?,"missing type for paramTPL")
+    assert(param.uml_type_one==pt,"paramTPM.uml_type should be equal to T")
+  end
+end
+module TestIncremental
+	def test_increment_AA
+		return unless is_EA71
+		findEvery( [Muml_Class]).each {|t|
+			next if t.uml_name.to_s!="AA"
+			fail "Model should not contain element AA"
+		}
+	end
+	def test_increment_AAb
+		return unless is_EA71
+		find("AA-rename",Muml_Class)
+	end
+end
+module TestEA
+	#EA does not support cardinality on parameter
+	#This with encode cardinality on parameter name:
+	# xxxx String[1..10] --> xxxx[1..10] String
+	def test_cardinality_parameter
+		#return unless is_EA71
+		#elt=find("paramListOfString[3..10]",Muml_Parameter)
+		elt=find("paramListOfString",Muml_Parameter)
+
+  		checkCardinalityLower(elt,/^3$/)
+  		checkCardinalityUpper(elt,/^10$/)
+	end
+end
+
+
+
+class Test_ontomde_base < Test::Unit::TestCase
+  include Modeler
+  include TestsEnumLit
+  include TestsStereotypes
+  include TestsStatic
+  include TestsGeneralisation
+  include TestsImplements
+  include TestsOwnedMember
+  include TestsNested
+  include RepositoryGetters
+  include TestsHelpers
+  include TestsOwnedOperation
+  include TestsOwnedAttribute
+  include TestAggregationKind
+  include TestsOrdered
+  include TestsReadOnly
+  include TestsDerived
+  include TestDocumentation
+  include TestCardinality
+  include TestVisibility
+  include TestType
+  include TestReturnParameter
+  include TestClassType
+  include TestUnique
+  include TestThrows
+  include TestEvery
+  include TestAbstract
+  include TestOwnedParameter
+  include TestBiNavigable
+  include TestDirectionParameter
+  include TestQualifier
+  include TestModel
+  include TestJavaSuite
+  include TestComponent
+  include TestStateMachine
+  include TestTemplate
+  include TestIncremental
+  include TestEA
+end
+
+def runOntomdeTest(file,modeler=Modeler::MODELER_UNKNOWN)
+  Dir.chdir(File.dirname(__FILE__))
+  MODELER.clear
+  MODELER.add(modeler)
+  UML_FILES.clear
+  if file.kind_of?(String)
+  	UML_FILES<< file
+  else
+	file.each { |f|
+  		UML_FILES<< f
+	}
+  end
+  Test::Unit::UI::Console::TestRunner.run(Test_ontomde_base)
+end
+
+#copy before it gets cleanup
+ARGVsaved=ARGV.clone