Changeset 12296


Ignore:
Timestamp:
Jan 25, 2019 4:50:00 PM (11 months ago)
Author:
mjohnsson
Message:

#5726 Adding all the inheritance tests

Location:
branches/dev-5726-orginal-annotation/Compiler/ModelicaFrontEnd
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-5726-orginal-annotation/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r12288 r12296  
    510510
    511511    /**
    512      *  Gives the Environment only including InstNodes
     512     *  Gives the environment filtered on this InstNode. The result includes only include modifications on/for this
     513     *  InstNode.
    513514     */
    514515    syn Environment InstNode.filteredEnvironment() = nameScope() ? myEnvironment(name()) : myEnvironment();
     
    528529    }
    529530
     531    /**
     532     * Helper method for calculating the environment.
     533     */
    530534    inh Environment InstExtends.myEnvironmentNoClass();
    531535    inh Environment InstExtends.myEnvironmentClass();
  • branches/dev-5726-orginal-annotation/Compiler/ModelicaFrontEnd/src/jastadd/util/Annotations.jrag

    r12094 r12296  
    6565
    6666    eq SrcFullClassDecl.annotation(InstContext instContext)           = annotationOfChild(getSrcAnnotationOpt(), instContext);
    67     eq InstClassDecl.annotation(InstContext instContext)              = getSrcClassDecl().annotation(instContext);
     67    eq InstClassDecl.annotation(InstContext instContext)              = mySrcAnnotatable().annotation(instContext);
     68    eq InstAbstractShortClassDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
    6869    eq SrcShortClassDecl.annotation(InstContext instContext)          = getSrcExtendsClauseShortClass().annotation(instContext);
    6970    eq SrcLibNode.annotation(InstContext instContext)                 = myClass().annotation(instContext);
     
    7374
    7475    eq SrcComponentDecl.annotation(InstContext instContext)  = getSrcComment().annotation(instContext);
    75     eq InstComponentDecl.annotation(InstContext instContext) = getSrcComponentDecl().annotation(instContext);
     76    eq InstComponentDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
    7677
    7778    public class FFunctionDecl     implements FAttributeListAnnotationNode.FAttributeList {}
     
    18931894    }
    18941895   
     1896    SrcModificationOrRedeclareElement extends SrcAnnotatable;
     1897    SrcClassDecl implements SrcAnnotatable;
     1898
     1899    public interface SrcAnnotatable {
     1900        public SrcAnnotationProvider srcAnnotationProvider();
     1901        public AnnotationNode annotation(InstContext instContext);
     1902    }
     1903
     1904    public SrcAnnotationProvider SrcModification.srcAnnotationProvider() {
     1905        return this;
     1906    }
     1907
     1908   
     1909    /**
     1910     * Find the topMost enclosing component.
     1911     * Return null if enclosingComponentDecl.
     1912     */
     1913    inh InstComponentDecl InstComponentDecl.topMostComponentDecl();
     1914    eq InstComponentDecl.getChild().topMostComponentDecl() {
     1915        InstComponentDecl next = topMostComponentDecl();
     1916        return next != null ? next : this;
     1917    }
     1918    eq InstRoot.getChild().topMostComponentDecl() = null;
     1919
     1920    /**
     1921     * Find the enclosing class to the topmost component
     1922     */
     1923    public InstClassDecl InstComponentDecl.enclosingClassTopMostComponentDecl() {
     1924        InstComponentDecl topComponent = topMostComponentDecl();
     1925        topComponent = topComponent != null ? topComponent : this;
     1926        return !topComponent.isUnknown() ? topComponent.enclosingInstClassDecl() : null;
     1927    }
     1928
     1929    /**
     1930     * Match the qualified name for a component or class against modifications in the enviroment
     1931     * Returns something annotatable either of 
     1932     */
     1933    public SrcAnnotatable InstClassDecl.matchFromEnviroment(String qualifiedName) {
     1934        Environment enviroment = myInstClass().myEnvironment();
     1935        for (InstModification im : enviroment) {
     1936            if (im.qualifiedMatches(qualifiedName)) {
     1937                SrcAnnotatable annotatable = im.getSrcModification();
     1938                SrcAnnotationProvider provider = annotatable.srcAnnotationProvider();
     1939                annotatable = provider.isClassRedeclare() ?
     1940                        provider.getSrcClassRedeclare() : annotatable;
     1941                if (annotatable.srcAnnotationProvider().hasAnnotation()) {
     1942                    return annotatable;
     1943                }
     1944            }
     1945        }
     1946        return null;
     1947    }
     1948   
     1949    /**
     1950     *
     1951     */
     1952    public SrcAnnotatable InstComponentDecl.matchFromEnviroment(String qualifiedName) {
     1953        Environment enviroment = filteredEnvironment();
     1954        for (InstModification im : enviroment) {
     1955            if (im.qualifiedMatches(qualifiedName)) {
     1956                SrcAnnotatable annotatable = im.getElementModification();
     1957                SrcAnnotationProvider provider = annotatable.srcAnnotationProvider();
     1958                annotatable = provider.isClassRedeclare() ?
     1959                        provider.getSrcClassRedeclare() : annotatable;
     1960                annotatable = provider.isComponentRedeclare() ?
     1961                        provider.getSrcClassRedeclare() : annotatable;
     1962                if (annotatable.srcAnnotationProvider().hasAnnotation()) {
     1963                    return annotatable;
     1964                }
     1965            }
     1966        }
     1967        return null;
     1968    }
     1969   
     1970    /**
     1971    * Includes the qualified class name for the class containing the topmost enclosing component.
     1972    * Equivalent to enclosingClassTopMostComponentDecl().qualifiedName()+ "." + qualifiedName()
     1973    */
     1974    syn String InstComponentDecl.fullyQualifiedName() =
     1975        enclosingClassTopMostComponentDecl().qualifiedName() + "." + qualifiedName();
     1976
     1977    syn String InstClassDecl.fullyQualifiedName() {
     1978        InstComponentDecl icomp = containingInstComponent();
     1979        if (icomp != null) {
     1980            return icomp.myInstClass().fullyQualifiedName() + "." + name();
     1981        }
     1982        return qualifiedName();
     1983    }
     1984   
     1985    syn String InstComponentDecl.fullyQualifiedTypeName() =
     1986        topMostComponentDecl().qualifiedTypeName() + "." + qualifiedName().replaceFirst(".*\\.", "");
     1987   
     1988    syn SrcAnnotatable InstModification.getElementModification() = getSrcModification();
     1989    eq InstValueModification.getElementModification() = elementModification();
     1990   
     1991    inh SrcAnnotatable InstValueModification.elementModification();
     1992    eq  InstModification.getChild().elementModification() = getSrcModification();
     1993    eq  InstComponentDecl.getChild().elementModification() = getSrcComponentDecl();
     1994    eq  InstClassDecl.getChild().elementModification() = getSrcClassDecl();
     1995    eq  InstNode.getChild().elementModification() = null;
     1996   
     1997    /** Match the correct modification and function  */
     1998    public boolean InstModification.qualifiedMatches(String qualifiedName) {
     1999        return qualifiedNameWithClass().equals(qualifiedName);
     2000    }
     2001   
     2002    /**
     2003     * Obtain the fully qualified name including containing class name of this component.
     2004     * Allows matching with the name provided from InstComponentDecl.fullyQualifiedName().
     2005     */
     2006    public String InstModification.qualifiedNameWithClass() {
     2007        return " ";
     2008    }
     2009   
     2010    public String InstValueModification.qualifiedNameWithClass() {
     2011        InstModification parent = parentInstModification();
     2012        if (parent != null && parent != this) {
     2013            return parent.qualifiedNameWithClass();
     2014        }
     2015        return myTargetComponent().fullyQualifiedName();
     2016    }
     2017
     2018    public String InstNamedModification.qualifiedNameWithClass() {
     2019        InstComponentDecl targetComponent = myTargetComponent();
     2020     
     2021        String fullName = "";
     2022        if (targetComponent.isUnknown()) {
     2023            InstClassDecl enclosingClass = enclosingInstClassDecl();
     2024            if (enclosingClass != null) {
     2025                fullName = enclosingClass.qualifiedName() + ".";
     2026            }
     2027            fullName = fullName + name();
     2028        }else {
     2029            fullName = targetComponent.fullyQualifiedName() + "." + name();
     2030        }
     2031        return fullName;
     2032    }
     2033
     2034   
     2035    public SrcAnnotatable InstClassDecl.orginalAnnotatable() {
     2036        return getSrcClassDecl();
     2037    }
     2038   
     2039    public SrcAnnotatable InstComponentDecl.orginalAnnotatable() = getSrcComponentDecl();
     2040   
     2041    public SrcAnnotatable InstReplacingShortClassDecl.orginalAnnotatable() {
     2042        SrcClassDecl clazz = getOriginalClassDecl();
     2043        if (!clazz.isUnknown()) {
     2044            SrcAnnotationProvider provider = clazz.srcAnnotationProvider();
     2045            if (provider.hasAnnotation()) {
     2046                return clazz;
     2047            }
     2048        }
     2049        return getSrcClassDecl();
     2050    }
     2051   
     2052    public SrcAnnotatable InstReplacingSimpleShortClassDecl.orginalAnnotatable() {
     2053        SrcClassDecl clazz = getOriginalClassDecl();
     2054        if (!clazz.isUnknown()) {
     2055            SrcAnnotationProvider provider = clazz.srcAnnotationProvider();
     2056            if (provider.hasAnnotation()) {
     2057                return clazz;
     2058            }
     2059        }
     2060        return getSrcClassDecl();
     2061    }
     2062
     2063    public SrcAnnotationProvider InstClassDecl.myAnnotation() {
     2064        return mySrcAnnotatable().srcAnnotationProvider();
     2065    }
     2066
     2067    public SrcAnnotatable InstComponentDecl.mySrcAnnotatable() {
     2068        SrcAnnotatable annotatable = matchFromEnviroment(fullyQualifiedName());
     2069        if (annotatable != null) {
     2070            return annotatable;
     2071        }
     2072        return getSrcComponentDecl();
     2073    }
     2074   
     2075    public SrcAnnotatable InstAbstractShortClassDecl.mySrcAnnotatable() {
     2076        boolean hasAnnotations = getSrcClassDecl().srcAnnotationProvider().hasAnnotation();
     2077        if (!hasAnnotations) {
     2078            if (myInstClass() != null) {
     2079                SrcAnnotatable annotatable = matchFromEnviroment(qualifiedName());
     2080                if (annotatable != null) {
     2081                    return annotatable;
     2082                }
     2083                annotatable = matchFromEnviroment(fullyQualifiedName());
     2084                if (annotatable != null) {
     2085                    return annotatable;
     2086                }
     2087                return orginalAnnotatable();
     2088            }
     2089        }
     2090        return getSrcClassDecl();
     2091    }
     2092
     2093    /**
     2094     * Obtain the source node which is responsable for annotations.
     2095     */
     2096    public SrcAnnotatable InstClassDecl.mySrcAnnotatable() {
     2097        return getSrcClassDecl();
     2098    }
     2099
     2100    /**
     2101     * Test method which obtains the string representation of the
     2102     * annotation for the only inner class to this class.
     2103     * Should not when multiple internal classes are present.
     2104     *
     2105     */
     2106    public String InstClassDecl.testOnlyAnnotation() {
     2107        InstClassDecl iclass = allInstClassDeclsIterator().next();
     2108        if (iclass == null  || iclass.isUnknown())
     2109            iclass = allInstClassDeclsIterator().next();
     2110       
     2111        Iterator<AnnotationNode> iter = iclass.annotation().iterator();
     2112        return iter.hasNext() ? iter.next().toString() : "";
     2113    }
     2114
     2115    /**
     2116     *  Test method which can obtain either a class or component of a given name from a
     2117     *  component in the current class.
     2118     */
     2119    public String InstClassDecl.testComponentAnnotations(boolean clazz, String name) {
     2120        StringBuilder sb = new StringBuilder();
     2121        for (InstComponentDecl icd : getInstComponentDecls()) {
     2122            InstNode annotable = null;
     2123            if (clazz) {
     2124                annotable = icd.genericLookupInstClass(name).targetOrNull();
     2125            } else {
     2126                for (InstComponentDecl inner : icd.allInstComponentDecls()) {
     2127                    if (inner.matches(name)) {
     2128                        annotable = inner;
     2129                    }
     2130                }
     2131            }
     2132            if (annotable != null) {
     2133                Iterator<AnnotationNode> iter = annotable.annotation().iterator();
     2134                sb.append(iter.hasNext() ? iter.next().toString() : "");
     2135                sb.append(System.lineSeparator());
     2136            }
     2137        }
     2138        return sb.toString();
     2139    }
     2140
    18952141}
    18962142
  • branches/dev-5726-orginal-annotation/Compiler/ModelicaFrontEnd/test/modelica/AnnotationTests.mo

    r10071 r12296  
    108108end ComponentConstrainedByBoth;
    109109
     110package inheritance
     111    package classes
     112        package BaseNoAnnotation
     113        end BaseNoAnnotation;
     114       
     115        model A
     116            replaceable package testPackage = BaseNoAnnotation annotation(Dialog(tab="a", group="b"));
     117            replaceable BaseNoAnnotation testComponent() annotation(Dialog(tab="ac", group="b"));
     118                annotation(__JModelica(UnitTesting(tests={
     119            InstClassMethodTestCase(
     120                name="instAnnotationFromRedeclare",
     121                description="Check that the Annotation .",
     122                methodName="testClassAnnotations",
     123                arguments={"testPackage"},
     124                methodResult="
     125    Dialog(tab = \"a\", group = \"b\")
     126    ")})));
     127        end A;
     128       
     129        model B
     130            extends A;
     131            annotation(__JModelica(UnitTesting(tests={
     132            InstClassMethodTestCase(
     133                name="extendedHaveAnnotation",
     134                description="Check that the Annotation .",
     135                methodName="testClassAnnotations",
     136                arguments={"testPackage"},
     137                methodResult="
     138    Dialog(tab = \"a\", group = \"b\")
     139    ")})));
     140        end B;
     141       
     142        model C
     143            extends A(
     144                redeclare replaceable package testPackage
     145                    = BaseNoAnnotation annotation(Dialog(tab="c", group="new")),
     146                redeclare replaceable BaseNoAnnotation testComponent()
     147                    annotation(Dialog(tab="cc", group="new")));
     148                   
     149            annotation(__JModelica(UnitTesting(tests={
     150            InstClassMethodTestCase(
     151                name="replacedInExtend",
     152                description="Check that the Annotation .",
     153                methodName="testClassAnnotations",
     154                arguments={"testPackage"},
     155                methodResult="Dialog(tab = \"c\", group = \"new\")")})));
     156        end C;
     157       
     158        model C2
     159            extends C(redeclare replaceable package testPackage = BaseNoAnnotation);
     160            annotation(__JModelica(UnitTesting(tests={
     161            InstClassMethodTestCase(
     162                name="extendNoRedeclare",
     163                description="Check that the Annotation .",
     164                methodName="testClassAnnotations",
     165                arguments={"testPackage"},
     166                methodResult="Dialog(tab = \"c\", group = \"new\")")})));
     167        end C2;
     168       
     169        model A2
     170            package BaseAnnotation
     171                replaceable BaseNoAnnotation testComponent();
     172                replaceable package testPackage = BaseNoAnnotation;
     173            end BaseAnnotation;
     174            BaseAnnotation.testComponent testComponent;
     175            BaseAnnotation.testPackage testPackage;
     176        end A2;
     177       
     178        package BaseAnnotationAlt
     179                replaceable BaseNoAnnotation testComponent() annotation(Dialog(group="altComponent"));
     180                replaceable package testPackage = BaseNoAnnotation annotation(Dialog(group="altPackage"));
     181            end BaseAnnotationAlt;
     182       
     183        model AnnotationFromReplacedContainingPackage
     184            extends A2(redeclare replaceable package BaseAnnotation = BaseAnnotationAlt)
     185            annotation(__JModelica(UnitTesting(tests={
     186            InstClassMethodTestCase(
     187                name="AnnotationFromReplacedContainingPackage",
     188                description="Check that the Annotation .",
     189                methodName="testClassAnnotations",
     190                arguments={"testPackage"},
     191                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     192        end AnnotationFromReplacedContainingPackage;
     193       
     194        model C3
     195            extends C(
     196                        redeclare replaceable BaseNoAnnotation testComponent() annotation(),
     197                        redeclare replaceable package testPackage = BaseNoAnnotation annotation()
     198                     );
     199            annotation(__JModelica(UnitTesting(tests={
     200            InstClassMethodTestCase(
     201                name="extendsEmptyReplace",
     202                description="Check that the Annotation .",
     203                methodName="testClassAnnotations",
     204                arguments={"testPackage"},
     205                methodResult="")})));
     206        end C3;
     207       
     208        model C4
     209            extends C(
     210                redeclare replaceable package testPackage
     211                    = BaseNoAnnotation annotation(Dialog(tab="c4", group="extends")),
     212                redeclare replaceable BaseNoAnnotation testComponent()
     213                    annotation(Dialog(tab="cc4", group="extends"))
     214                    );
     215            annotation(__JModelica(UnitTesting(tests={
     216            InstClassMethodTestCase(
     217                name="extendedReplacement",
     218                description="Check that the Annotation .",
     219                methodName="testClassAnnotations",
     220                arguments={"testPackage"},
     221                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     222        end C4;
     223           
     224        model C5
     225            extends C4;
     226            annotation(__JModelica(UnitTesting(tests={
     227            InstClassMethodTestCase(
     228                name="extendExtendReplacement",
     229                description="Check that the Annotation .",
     230                methodName="testClassAnnotations",
     231                arguments={"testPackage"},
     232                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     233        end C5;
     234       
     235        model D
     236            extends A(
     237                redeclare replaceable BaseNoAnnotation testComponent() annotation(),
     238                redeclare replaceable package testPackage = BaseNoAnnotation annotation());
     239            annotation(__JModelica(UnitTesting(tests={
     240            InstClassMethodTestCase(
     241                name="emptyExtendReplace",
     242                description="Check that the Annotation .",
     243                methodName="testClassAnnotations",
     244                arguments={"testPackage"},
     245                methodResult="")})));
     246        end D;
     247       
     248        model D2
     249            extends D;
     250            annotation(__JModelica(UnitTesting(tests={
     251            InstClassMethodTestCase(
     252                name="extendEmptyFromExtend",
     253                description="Check that the Annotation .",
     254                methodName="testClassAnnotations",
     255                arguments={"testPackage"},
     256                methodResult="")})));
     257        end D2;
     258       
     259        model E
     260            extends A(
     261                redeclare replaceable package testPackage = BaseNoAnnotation,
     262                redeclare replaceable BaseNoAnnotation testComponent()
     263                );
     264            annotation(__JModelica(UnitTesting(tests={
     265            InstClassMethodTestCase(
     266                name="noneReplacingRedeclaration",
     267                description="Check that the Annotation .",
     268                methodName="testClassAnnotations",
     269                arguments={"testPackage"},
     270                methodResult="
     271    Dialog(tab = \"a\", group = \"b\")
     272    ")})));
     273        end E;
     274   
     275        model E2
     276            extends E;
     277            annotation(__JModelica(UnitTesting(tests={
     278            InstClassMethodTestCase(
     279                name="extendNoneReplacingRedeclaration",
     280                description="Check that the Annotation .",
     281                methodName="testClassAnnotations",
     282                arguments={"testPackage"},
     283                methodResult="
     284    Dialog(tab = \"a\", group = \"b\")
     285    ")})));
     286        end E2;
     287    end classes;
     288   
     289   
     290    package components
     291        import AnnotationTests.inheritance.classes.*;
     292        model redeclaredWithAnnotationInExtends
     293            C redeclaredWithAnnotationInExtends;
     294            annotation(__JModelica(UnitTesting(tests={
     295                InstClassMethodTestCase(
     296                    name="redeclaredWithAnnotationInExtends",
     297                    description="Annotation from Extends for component inner class.",
     298                    methodName="testComponentAnnotations",
     299                    arguments={true, "testPackage"},
     300                    methodResult="
     301        Dialog(tab = \"c\", group = \"new\")
     302        ")}))); 
     303        end  redeclaredWithAnnotationInExtends;
     304       
     305        model redeclaredWithNoAnnotationInExtends
     306            C2 redeclaredWithNoAnnotationInExtends;
     307            annotation(__JModelica(UnitTesting(tests={
     308                InstClassMethodTestCase(
     309                    name="redeclaredWithNoAnnotationInExtends",
     310                    description="Base annotation since not change in Extends for component inner class.",
     311                    methodName="testComponentAnnotations",
     312                    arguments={true, "testPackage"},
     313                    methodResult="
     314        Dialog(tab = \"c\", group = \"new\")
     315        ")}))); 
     316        end redeclaredWithNoAnnotationInExtends;
     317       
     318        model redeclaredWithEmptyAnnotationInExtends
     319            C3 redeclaredWithEmptyAnnotationInExtends;
     320            annotation(__JModelica(UnitTesting(tests={
     321                InstClassMethodTestCase(
     322                    name="redeclaredWithEmptyAnnotationInExtends",
     323                    description="Empty annotation removes the original annotation.",
     324                    methodName="testComponentAnnotations",
     325                    arguments={true, "testPackage"},
     326                    methodResult="
     327
     328        ")})));             
     329        end redeclaredWithEmptyAnnotationInExtends;
     330       
     331        model redeclaredInOwnAndAncestorsExtends
     332            C4 redeclaredInOwnAndAncestorsExtends;
     333            annotation(__JModelica(UnitTesting(tests={
     334                InstClassMethodTestCase(
     335                    name="redeclaredInOwnAndAncestorsExtends",
     336                    description="Annotation from latest extends for component inner class.",
     337                    methodName="testComponentAnnotations",
     338                    arguments={true, "testPackage"},
     339                    methodResult="
     340        Dialog(tab = \"c4\", group = \"extends\")
     341        ")})));             
     342        end redeclaredInOwnAndAncestorsExtends;
     343       
     344        model redeclaredInParentExtends
     345            C5 redeclaredInParentExtends;
     346            annotation(__JModelica(UnitTesting(tests={
     347                InstClassMethodTestCase(
     348                    name="redeclaredInParentExtends",
     349                    description="Annotation from parent extends for component inner class.",
     350                    methodName="testComponentAnnotations",
     351                    arguments={true, "testPackage"},
     352                    methodResult="
     353        Dialog(tab = \"c4\", group = \"extends\")
     354        ")}))); 
     355        end redeclaredInParentExtends;
     356       
     357        model redeclaredInDeclarationNoAnnotation
     358            C5 redeclaredInDeclarationNoAnnotation(
     359                    redeclare replaceable package testPackage = BaseNoAnnotation,
     360                    redeclare replaceable BaseNoAnnotation testComponent());
     361            annotation(__JModelica(UnitTesting(tests={
     362                InstClassMethodTestCase(
     363                    name="redeclaredInDeclarationNoAnnotation",
     364                    description="Check that the components have correct annotation.",
     365                    methodName="testComponentAnnotations",
     366                    arguments={true, "testPackage"},
     367                    methodResult="
     368        Dialog(tab=\"c4\", group=\"extends\")
     369        ")})));                 
     370        end redeclaredInDeclarationNoAnnotation;
     371       
     372        model redeclaredInDeclarationWithEmptyAnnotation
     373            C5 redeclaredInDeclarationWithEmptyAnnotation(
     374                    redeclare replaceable package testPackage = BaseNoAnnotation annotation(),
     375                    redeclare replaceable BaseNoAnnotation testComponent() annotation());
     376            annotation(__JModelica(UnitTesting(tests={
     377                InstClassMethodTestCase(
     378                    name="redeclaredInDeclarationWithEmptyAnnotation",
     379                    description="Check that the components have correct annotation.",
     380                    methodName="testComponentAnnotations",
     381                    arguments={true, "testPackage"},
     382                    methodResult="
     383
     384        ")})));           
     385        end redeclaredInDeclarationWithEmptyAnnotation;
     386       
     387        model redeclaredInDeclaration
     388            C5  redeclaredInDeclaration(
     389                    redeclare replaceable package testPackage = BaseNoAnnotation
     390                        annotation(Dialog(tab="redeclaredInDeclaration", group="extends")));
     391            annotation(__JModelica(UnitTesting(tests={
     392                InstClassMethodTestCase(
     393                    name="redeclaredInDeclaration",
     394                    description="Check that the components have correct annotation.",
     395                    methodName="testComponentAnnotations",
     396                    arguments={true, "testPackage"},
     397                    methodResult="
     398        Dialog(tab = \"redeclaredInDeclaration\", group = \"extends\")
     399        ")}))); 
     400        end redeclaredInDeclaration;
     401    end components;
     402   
     403    package componentsGetComponent
     404        import AnnotationTests.inheritance.classes.*;
     405        model componentRedeclaredWithAnnotationInExtends
     406            C redeclaredWithAnnotationInExtends;
     407            annotation(__JModelica(UnitTesting(tests={
     408                InstClassMethodTestCase(
     409                    name="componentRedeclaredWithAnnotationInExtends",
     410                    description="Annotation from Extends for component inner component.",
     411                    methodName="testComponentAnnotations",
     412                    arguments={false, "testComponent"},
     413                    methodResult="
     414        Dialog(tab = \"cc\", group = \"new\")
     415        ")}))); 
     416        end  componentRedeclaredWithAnnotationInExtends;
     417       
     418        model componentRedeclaredWithNoAnnotationInExtends
     419            C2 redeclaredWithNoAnnotationInExtends;
     420            annotation(__JModelica(UnitTesting(tests={
     421                InstClassMethodTestCase(
     422                    name="componentRedeclaredWithNoAnnotationInExtends",
     423                    description="Check that the components have correct annotation.",
     424                    methodName="testComponentAnnotations",
     425                    arguments={false, "testComponent"},
     426                    methodResult="
     427        Dialog(tab = \"cc\", group = \"new\")
     428        ")}))); 
     429        end componentRedeclaredWithNoAnnotationInExtends;
     430       
     431        model componentRedeclaredWithEmptyAnnotationInExtends
     432            C3 redeclaredWithEmptyAnnotationInExtends;
     433            annotation(__JModelica(UnitTesting(tests={
     434                InstClassMethodTestCase(
     435                    name="componentRedeclaredWithEmptyAnnotationInExtends",
     436                    description="Check that the components have correct annotation.",
     437                    methodName="testComponentAnnotations",
     438                    arguments={false, "testComponent"},
     439                    methodResult="
     440
     441        ")})));             
     442        end componentRedeclaredWithEmptyAnnotationInExtends;
     443       
     444        model componentRedeclaredInOwnAndAncestorsExtends
     445            C4 redeclaredInOwnAndAncestorsExtends;
     446            annotation(__JModelica(UnitTesting(tests={
     447                InstClassMethodTestCase(
     448                    name="componentRedeclaredInOwnAndAncestorsExtends",
     449                    description="Check that the components have correct annotation.",
     450                    methodName="testComponentAnnotations",
     451                    arguments={false, "testComponent"},
     452                    methodResult="
     453        Dialog(tab = \"cc4\", group = \"extends\")
     454        ")})));             
     455        end componentRedeclaredInOwnAndAncestorsExtends;
     456       
     457        model componentRedeclaredInParentExtends
     458            C5 redeclaredInParentExtends;
     459            annotation(__JModelica(UnitTesting(tests={
     460                InstClassMethodTestCase(
     461                    name="componentRedeclaredInParentExtends",
     462                    description="Check that the components have correct annotation.",
     463                    methodName="testComponentAnnotations",
     464                    arguments={false, "testComponent"},
     465                    methodResult="
     466        Dialog(tab = \"cc4\", group = \"extends\")
     467        ")}))); 
     468        end componentRedeclaredInParentExtends;
     469       
     470        model componentRedeclaredInDeclarationNoAnnotation
     471            C5 redeclaredInDeclarationNoAnnotation(
     472                    redeclare replaceable package testPackage = BaseNoAnnotation,
     473                    redeclare replaceable BaseNoAnnotation testComponent());
     474            annotation(__JModelica(UnitTesting(tests={
     475                InstClassMethodTestCase(
     476                    name="componentRedeclaredInDeclarationNoAnnotation",
     477                    description="Check that the components have correct annotation.",
     478                    methodName="testComponentAnnotations",
     479                    arguments={false, "testComponent"},
     480                    methodResult="
     481        Dialog(tab=\"cc4\", group=\"extends\")
     482        ")})));                 
     483        end componentRedeclaredInDeclarationNoAnnotation;
     484       
     485        model componentRedeclaredInDeclarationWithEmptyAnnotation
     486            C5 redeclaredInDeclarationWithEmptyAnnotation(
     487                    redeclare replaceable package testPackage = BaseNoAnnotation annotation(),
     488                    redeclare replaceable BaseNoAnnotation testComponent() annotation());
     489            annotation(__JModelica(UnitTesting(tests={
     490                InstClassMethodTestCase(
     491                    name="componentRedeclaredInDeclarationWithEmptyAnnotation",
     492                    description="Check that the components have correct annotation.",
     493                    methodName="testComponentAnnotations",
     494                    arguments={false, "TestComponent"},
     495                    methodResult="
     496
     497        ")})));           
     498        end componentRedeclaredInDeclarationWithEmptyAnnotation;
     499       
     500        model componentRedeclaredInDeclaration
     501            C5  redeclaredInDeclaration(
     502                    redeclare replaceable package testPackage = BaseNoAnnotation
     503                        annotation(Dialog(tab="redeclaredInDeclaration", group="extends")),
     504                    redeclare replaceable BaseNoAnnotation testComponent()
     505                        annotation(Dialog(tab="redeclaredInDeclaration", group="component"))
     506                    );
     507            annotation(__JModelica(UnitTesting(tests={
     508                InstClassMethodTestCase(
     509                    name="componentRedeclaredInDeclaration",
     510                    description="Check that the components have correct annotation.",
     511                    methodName="testComponentAnnotations",
     512                    arguments={false, "testComponent"},
     513                    methodResult="
     514        Dialog(tab = \"redeclaredInDeclaration\", group = \"component\")
     515        ")}))); 
     516        end componentRedeclaredInDeclaration;
     517    end componentsGetComponent;
     518end inheritance;
    110519
    111520end AnnotationTests;
Note: See TracChangeset for help on using the changeset viewer.