gerrit.o-ran-sc Code Review - smo/teiv.git/blob

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024 Ericsson
   4  *  Modifications Copyright (C) 2024 OpenInfra Foundation Europe
   5  *  ================================================================================
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  *
  18  *  SPDX-License-Identifier: Apache-2.0
  19  *  ============LICENSE_END=========================================================
  20  */
  21 package org.oran.smo.yangtools.parser.model.statements.yang.test;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.junit.Assert.fail;
  26
  27 import java.math.BigDecimal;
  28 import java.util.Arrays;
  29 import java.util.List;
  30
  31 import org.junit.Test;
  32
  33 import org.oran.smo.yangtools.parser.findings.ParserFindingType;
  34 import org.oran.smo.yangtools.parser.model.resolvers.TypeResolver;
  35 import org.oran.smo.yangtools.parser.model.statements.yang.CY;
  36 import org.oran.smo.yangtools.parser.model.statements.yang.YContainer;
  37 import org.oran.smo.yangtools.parser.model.statements.yang.YLeaf;
  38 import org.oran.smo.yangtools.parser.model.statements.yang.YModule;
  39 import org.oran.smo.yangtools.parser.model.statements.yang.YType;
  40 import org.oran.smo.yangtools.parser.model.yangdom.YangDomElement;
  41 import org.oran.smo.yangtools.parser.testutils.YangTestCommon;
  42 import org.oran.smo.yangtools.parser.util.NamespaceModuleIdentifier;
  43
  44 public class TypedefTest extends YangTestCommon {
  45
  46     private static final String TEST_MODULE_NS = "test:typedef-test-module";
  47     private static final String TEST_MODULE_NAME = "typedef-test-module";
  48
  49     private static final String TEST_IMPORTING_MODULE_NS = "test:typedef-test-importing-module";
  50     private static final String TEST_IMPORTING_MODULE_NAME = "typedef-test-importing-module";
  51
  52     @Test
  53     public void testTypedef() {
  54
  55         severityCalculator.suppressFinding(ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
  56         severityCalculator.suppressFinding(ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY.toString());
  57
  58         context.setSuppressFindingsOnUnusedSchemaNodes(false);
  59         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-module.yang",
  60                 "typedef-test/typedef-test-submodule.yang", "typedef-test/typedef-test-importing-module.yang"));
  61
  62         final YModule module = getModule("typedef-test-module");
  63         final YModule importingModule = getModule("typedef-test-importing-module");
  64
  65         // - - - - lots of nesting - - - - - - -
  66
  67         assertNoFindingsOnStatement(getTypedef(module, "typedef1"));
  68         assertDomElementHasFindingOfType(getTypedef(module, "typedef5").getDomElement().getChildren().get(0),
  69                 ParserFindingType.P112_EXCESSIVE_TYPEDEF_DEPTH.toString());
  70
  71         final YContainer cont1 = getContainer(module, "cont1");
  72
  73         final YLeaf leaf01 = getLeaf(cont1, "leaf01");
  74         assertOriginalTypedefStackSize(leaf01.getType(), 1);
  75         assertOriginalTypedef(leaf01.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  76                 "typedef1"));
  77
  78         final YLeaf leaf02 = getLeaf(cont1, "leaf02");
  79         assertOriginalTypedefStackSize(leaf02.getType(), 2);
  80         assertOriginalTypedef(leaf02.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  81                 "typedef1"));
  82         assertOriginalTypedef(leaf02.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  83                 "typedef2"));
  84
  85         final YLeaf leaf05 = getLeaf(cont1, "leaf05");
  86         assertOriginalTypedefStackSize(leaf05.getType(), 5);
  87         assertOriginalTypedef(leaf05.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  88                 "typedef1"));
  89         assertOriginalTypedef(leaf05.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  90                 "typedef2"));
  91         assertOriginalTypedef(leaf05.getType(), 4, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
  92                 "typedef5"));
  93
  94         // - - - - circular - - - - - - -
  95
  96         assertStatementHasFindingOfType(getTypedef(module, "typedef7").getType(),
  97                 ParserFindingType.P111_CIRCULAR_TYPEDEF_REFERENCES.toString());
  98         assertStatementHasFindingOfType(getTypedef(module, "typedef8").getType(),
  99                 ParserFindingType.P111_CIRCULAR_TYPEDEF_REFERENCES.toString());
 100         assertStatementHasFindingOfType(getTypedef(module, "typedef9").getType(),
 101                 ParserFindingType.P111_CIRCULAR_TYPEDEF_REFERENCES.toString());
 102
 103         // - - - - bad typedef name - - - - - - -
 104
 105         assertStatementHasFindingOfType(getTypedef(module, "uint32"), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 106                 .toString());
 107         assertStatementHasFindingOfType(getTypedef(module, ""), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 108                 .toString());
 109         assertStatementHasFindingOfType(getTypedef(module, "my custom type"), ParserFindingType.P052_INVALID_YANG_IDENTIFIER
 110                 .toString());
 111         assertStatementHasFindingOfType(getTypedef(module, null), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 112                 .toString());
 113
 114         // - - - - not resolvable - - - - - - -
 115
 116         assertStatementHasFindingOfType(getTypedef(module, "typedef11").getType(),
 117                 ParserFindingType.P113_UNRESOLVABLE_DERIVED_TYPE.toString());
 118         assertStatementHasFindingOfType(getTypedef(module, "typedef12").getType(),
 119                 ParserFindingType.P116_NESTED_DERIVED_TYPE_NOT_RESOLVABLE.toString());
 120
 121         // - - - - - resolvable, with and without prefix - - - - -
 122
 123         assertNoFindingsOnStatement(getTypedef(module, "typedef13"));
 124         assertNoFindingsOnStatement(getTypedef(module, "typedef14"));
 125         assertTrue(getTypedef(module, "typedef14").getType().getDataType().equals("uint32"));
 126         assertNoFindingsOnStatement(getTypedef(module, "typedef15"));
 127         assertTrue(getTypedef(module, "typedef15").getType().getDataType().equals("uint32"));
 128
 129         // - - - - - from submodule - - - - -
 130
 131         assertNoFindingsOnStatement(getTypedef(module, "typedef16"));
 132         assertNoFindingsOnStatement(getTypedef(module, "typedef17"));
 133         assertNoFindingsOnStatement(getTypedef(module, "typedef91"));
 134         assertNoFindingsOnStatement(getTypedef(module, "typedef92"));
 135         assertNoFindingsOnStatement(getTypedef(module, "typedef93"));
 136         assertTrue(getTypedef(module, "typedef16").getType().getDataType().equals("boolean"));
 137         assertTrue(getTypedef(module, "typedef17").getType().getDataType().equals("uint32"));
 138
 139         assertTrue(getLeaf(importingModule, "leaf1").getType().getDataType().equals("uint32"));
 140         assertTrue(getLeaf(importingModule, "leaf2").getType().getDataType().equals("boolean"));
 141         assertTrue(getLeaf(importingModule, "leaf3").getType().getDataType().equals("uint32"));
 142
 143         final YContainer cont2 = getContainer(module, "cont2");
 144
 145         final YLeaf leaf21 = getLeaf(cont2, "leaf21");
 146         assertOriginalTypedefStackSize(leaf21.getType(), 3);
 147         assertOriginalTypedef(leaf21.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 148                 "typedef92"));
 149         assertOriginalTypedef(leaf21.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 150                 "typedef91"));
 151         assertOriginalTypedef(leaf21.getType(), 2, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 152                 "typedef16"));
 153
 154         final YLeaf leaf22 = getLeaf(cont2, "leaf22");
 155         assertOriginalTypedefStackSize(leaf22.getType(), 3);
 156         assertOriginalTypedef(leaf22.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 157                 "typedef13"));
 158         assertOriginalTypedef(leaf22.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 159                 "typedef93"));
 160         assertOriginalTypedef(leaf22.getType(), 2, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 161                 "typedef17"));
 162
 163         // - - - - - bad types - - - - -
 164
 165         assertStatementHasFindingOfType(getTypedef(module, "typedef18").getType(),
 166                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 167         assertStatementHasFindingOfType(getTypedef(module, "typedef19").getType(),
 168                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 169         assertStatementHasFindingOfType(getTypedef(module, "typedef20").getType(),
 170                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 171         assertStatementHasFindingOfType(getTypedef(module, "typedef21").getType(),
 172                 ParserFindingType.P113_UNRESOLVABLE_DERIVED_TYPE.toString());
 173
 174         // - - - - - importing - - - - -
 175
 176         final YLeaf leaf1 = getLeaf(importingModule, "leaf1");
 177         assertOriginalTypedefStackSize(leaf1.getType(), 1);
 178         assertOriginalTypedef(leaf1.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 179                 "typedef13"));
 180
 181         final YLeaf leaf2 = getLeaf(importingModule, "leaf2");
 182         assertOriginalTypedefStackSize(leaf2.getType(), 1);
 183         assertOriginalTypedef(leaf2.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 184                 "typedef92"));
 185
 186         final YLeaf leaf4 = getLeaf(importingModule, "leaf4");
 187         assertOriginalTypedefStackSize(leaf4.getType(), 3);
 188         assertOriginalTypedef(leaf4.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 189                 "typedef13"));
 190         assertOriginalTypedef(leaf4.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 191                 "typedef93"));
 192         assertOriginalTypedef(leaf4.getType(), 2, new NamespaceModuleIdentifier(TEST_IMPORTING_MODULE_NS,
 193                 TEST_IMPORTING_MODULE_NAME, "typedef51"));
 194
 195         final YContainer cont6 = getContainer(importingModule, "cont6");
 196         final YLeaf leaf5 = getLeaf(cont6, "leaf5");
 197         assertOriginalTypedefStackSize(leaf5.getType(), 2);
 198         assertOriginalTypedef(leaf5.getType(), new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 199                 "typedef13"));
 200         assertOriginalTypedef(leaf5.getType(), 1, new NamespaceModuleIdentifier(TEST_MODULE_NS, TEST_MODULE_NAME,
 201                 "typedef93"));
 202     }
 203
 204     @Test
 205     public void test___typedef___not_used_or_used_once_only() {
 206
 207         context.setSuppressFindingsOnUnusedSchemaNodes(true);
 208         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-not-used-once-used.yang"));
 209
 210         final YModule module = getModule("typedef-test-not-used-once-used");
 211
 212         assertStatementHasFindingOfType(getTypedef(module, "typedef1"), ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
 213         assertStatementHasFindingOfType(getTypedef(module, "typedef2"), ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY
 214                 .toString());
 215         assertNoFindingsOnStatement(getTypedef(module, "typedef3"));
 216     }
 217
 218     @Test
 219     public void test_Typedef_no_submodule() {
 220
 221         severityCalculator.suppressFinding(ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
 222         severityCalculator.suppressFinding(ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY.toString());
 223
 224         context.setSuppressFindingsOnUnusedSchemaNodes(false);
 225         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-module.yang",
 226                 "typedef-test/typedef-test-importing-module.yang"));
 227
 228         assertHasFindingOfType(ParserFindingType.P037_UNRESOLVABLE_INCLUDE.toString());
 229
 230         final YModule module = getModule("typedef-test-module");
 231
 232         // - - - - - from submodule - - - - -
 233
 234         assertStatementHasFindingOfType(getTypedef(module, "typedef16").getType(),
 235                 ParserFindingType.P113_UNRESOLVABLE_DERIVED_TYPE.toString());
 236         assertStatementHasFindingOfType(getTypedef(module, "typedef17").getType(),
 237                 ParserFindingType.P113_UNRESOLVABLE_DERIVED_TYPE.toString());
 238     }
 239
 240     @Test
 241     public void test_Typedef_restrictions() {
 242
 243         severityCalculator.suppressFinding(ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
 244         severityCalculator.suppressFinding(ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY.toString());
 245         severityCalculator.suppressFinding(ParserFindingType.P143_ENUM_WITHOUT_VALUE.toString());
 246         severityCalculator.suppressFinding(ParserFindingType.P144_BIT_WITHOUT_POSITION.toString());
 247
 248         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-restrictions-module.yang"));
 249
 250         final YModule module = getModule("typedef-test-restrictions-module");
 251
 252         // - - - - - - no changes - - - - - -
 253
 254         final YContainer cont1 = getContainer(module, "cont1");
 255         assertSubTreeNoFindings(cont1);
 256
 257         assertTrue(getLeaf(cont1, "leaf1").getDefault().getValue().equals("Hello"));
 258         assertTrue(getLeaf(cont1, "leaf1").getType().getDataType().equals("string"));
 259         assertTrue(getLeaf(cont1, "leaf1").getType().getLength().getBoundaries().size() == 1);
 260         assertTrue(getLeaf(cont1, "leaf1").getType().getLength().getBoundaries().get(0).lower == 10);
 261         assertTrue(getLeaf(cont1, "leaf1").getType().getLength().getBoundaries().get(0).upper == 20);
 262         assertTrue(getLeaf(cont1, "leaf1").getType().getPatterns().size() == 1);
 263         assertTrue(getLeaf(cont1, "leaf1").getType().getPatterns().get(0).getPattern().equals("ab*c"));
 264
 265         assertTrue(getLeaf(cont1, "leaf2").getDefault().getDecimalDefaultValue().compareTo(BigDecimal.valueOf(35L)) == 0);
 266         assertTrue(getLeaf(cont1, "leaf2").getType().getDataType().equals("int32"));
 267         assertTrue(getLeaf(cont1, "leaf2").getType().getRange().getBoundaries().size() == 1);
 268         assertTrue(getLeaf(cont1, "leaf2").getType().getRange().getBoundaries().get(0).lower.compareTo(BigDecimal.valueOf(
 269                 30)) == 0);
 270         assertTrue(getLeaf(cont1, "leaf2").getType().getRange().getBoundaries().get(0).upper.compareTo(BigDecimal.valueOf(
 271                 40)) == 0);
 272
 273         assertTrue(getLeaf(cont1, "leaf3").getDefault().getValue().equals("one"));
 274         assertTrue(getLeaf(cont1, "leaf3").getType().getDataType().equals("enumeration"));
 275         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().size() == 3);
 276         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(0).getEnumName().equals("zero"));
 277         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(0).getValue().getValue().equals("10"));
 278         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(1).getEnumName().equals("one"));
 279         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(1).getValue().getValue().equals("11"));
 280         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(2).getEnumName().equals("two"));
 281         assertTrue(getLeaf(cont1, "leaf3").getType().getEnums().get(2).getValue().getValue().equals("12"));
 282
 283         assertTrue(getLeaf(cont1, "leaf4").getDefault() == null);
 284         assertTrue(getLeaf(cont1, "leaf4").getType().getDataType().equals("bits"));
 285         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().size() == 3);
 286         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(0).getBitName().equals("four"));
 287         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(0).getPosition().getValue().equals("16"));
 288         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(1).getBitName().equals("five"));
 289         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(1).getPosition().getValue().equals("17"));
 290         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(2).getBitName().equals("six"));
 291         assertTrue(getLeaf(cont1, "leaf4").getType().getBits().get(2).getPosition().getValue().equals("18"));
 292
 293         // - - - - - - some overrides - - - - - -
 294
 295         final YContainer cont2 = getContainer(module, "cont2");
 296         assertSubTreeNoFindings(cont2);
 297
 298         assertTrue(getLeaf(cont2, "leaf7").getDefault().getValue().equals("World"));
 299         assertTrue(getLeaf(cont2, "leaf7").getType().getDataType().equals("string"));
 300         assertTrue(getLeaf(cont2, "leaf7").getType().getLength().getBoundaries().size() == 1);
 301         assertTrue(getLeaf(cont2, "leaf7").getType().getLength().getBoundaries().get(0).lower == 12);
 302         assertTrue(getLeaf(cont2, "leaf7").getType().getLength().getBoundaries().get(0).upper == 15);
 303         assertTrue(getLeaf(cont2, "leaf7").getType().getPatterns().size() == 2);
 304         assertTrue(getLeaf(cont2, "leaf7").getType().getPatterns().get(0).getPattern().equals("ab*c"));
 305         assertTrue(getLeaf(cont2, "leaf7").getType().getPatterns().get(1).getPattern().equals("de*f"));
 306
 307         assertTrue(getLeaf(cont2, "leaf8").getDefault().getDecimalDefaultValue().compareTo(BigDecimal.valueOf(32L)) == 0);
 308         assertTrue(getLeaf(cont2, "leaf8").getType().getDataType().equals("int32"));
 309         assertTrue(getLeaf(cont2, "leaf8").getType().getRange().getBoundaries().size() == 1);
 310         assertTrue(getLeaf(cont2, "leaf8").getType().getRange().getBoundaries().get(0).lower.compareTo(BigDecimal.valueOf(
 311                 30)) == 0);
 312         assertTrue(getLeaf(cont2, "leaf8").getType().getRange().getBoundaries().get(0).upper.compareTo(BigDecimal.valueOf(
 313                 35)) == 0);
 314
 315         assertTrue(getLeaf(cont2, "leaf9").getDefault().getValue().equals("zero"));
 316         assertTrue(getLeaf(cont2, "leaf9").getType().getDataType().equals("enumeration"));
 317         assertTrue(getLeaf(cont2, "leaf9").getType().getEnums().size() == 2);
 318         assertTrue(getLeaf(cont2, "leaf9").getType().getEnums().get(0).getEnumName().equals("zero"));
 319         assertTrue(getLeaf(cont2, "leaf9").getType().getEnums().get(0).getValue().getValue().equals("10"));
 320         assertTrue(getLeaf(cont2, "leaf9").getType().getEnums().get(1).getEnumName().equals("one"));
 321         assertTrue(getLeaf(cont2, "leaf9").getType().getEnums().get(1).getValue().getValue().equals("11"));
 322
 323         assertTrue(getLeaf(cont2, "leaf10").getDefault().getValue().equals("six"));
 324         assertTrue(getLeaf(cont2, "leaf10").getType().getDataType().equals("bits"));
 325         assertTrue(getLeaf(cont2, "leaf10").getType().getBits().size() == 2);
 326         assertTrue(getLeaf(cont2, "leaf10").getType().getBits().get(0).getBitName().equals("five"));
 327         assertTrue(getLeaf(cont2, "leaf10").getType().getBits().get(0).getPosition().getValue().equals("17"));
 328         assertTrue(getLeaf(cont2, "leaf10").getType().getBits().get(1).getBitName().equals("six"));
 329         assertTrue(getLeaf(cont2, "leaf10").getType().getBits().get(1).getPosition().getValue().equals("18"));
 330
 331         // - - - - - - some multi-level overrides - - - - - -
 332
 333         final YContainer cont3 = getContainer(module, "cont3");
 334         assertSubTreeNoFindings(cont3);
 335
 336         assertTrue(getLeaf(cont3, "leaf18").getDefault().getValue().equals("Moon"));
 337         assertTrue(getLeaf(cont3, "leaf18").getType().getDataType().equals("string"));
 338         assertTrue(getLeaf(cont3, "leaf18").getType().getLength().getBoundaries().size() == 1);
 339         assertTrue(getLeaf(cont3, "leaf18").getType().getLength().getBoundaries().get(0).lower == 6);
 340         assertTrue(getLeaf(cont3, "leaf18").getType().getLength().getBoundaries().get(0).upper == 7);
 341         assertTrue(getLeaf(cont3, "leaf18").getType().getPatterns().size() == 3);
 342         assertTrue(getLeaf(cont3, "leaf18").getType().getPatterns().get(0).getPattern().equals("ab*c"));
 343         assertTrue(getLeaf(cont3, "leaf18").getType().getPatterns().get(1).getPattern().equals("gh*i"));
 344         assertTrue(getLeaf(cont3, "leaf18").getType().getPatterns().get(2).getPattern().equals("mn*o"));
 345
 346         assertTrue(getLeaf(cont3, "leaf19").getDefault().getDecimalDefaultValue().compareTo(BigDecimal.valueOf(13L)) == 0);
 347         assertTrue(getLeaf(cont3, "leaf19").getType().getDataType().equals("int32"));
 348         assertTrue(getLeaf(cont3, "leaf19").getType().getRange().getBoundaries().size() == 1);
 349         assertTrue(getLeaf(cont3, "leaf19").getType().getRange().getBoundaries().get(0).lower.compareTo(BigDecimal.valueOf(
 350                 16)) == 0);
 351         assertTrue(getLeaf(cont3, "leaf19").getType().getRange().getBoundaries().get(0).upper.compareTo(BigDecimal.valueOf(
 352                 17)) == 0);
 353
 354         assertTrue(getLeaf(cont3, "leaf20").getDefault().getValue().equals("one"));
 355         assertTrue(getLeaf(cont3, "leaf20").getType().getDataType().equals("enumeration"));
 356         assertTrue(getLeaf(cont3, "leaf20").getType().getEnums().size() == 1);
 357         assertTrue(getLeaf(cont3, "leaf20").getType().getEnums().get(0).getEnumName().equals("one"));
 358         assertTrue(getLeaf(cont3, "leaf20").getType().getEnums().get(0).getValue().getValue().equals("11"));
 359
 360         // - - - - - - some illegal statements for restriction - - - - - -
 361
 362         final YContainer cont4 = getContainer(module, "cont4");
 363
 364         final YangDomElement leaf28domElement = getDomChild(cont4.getDomElement(), CY.LEAF, "leaf28");
 365         assertDomElementHasFindingOfType(leaf28domElement, ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 366
 367         final YangDomElement leaf29domElement = getDomChild(cont4.getDomElement(), CY.LEAF, "leaf29");
 368         assertDomElementHasFindingOfType(leaf29domElement, ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 369
 370         final YangDomElement leaf30domElement = getDomChild(cont4.getDomElement(), CY.LEAF, "leaf30");
 371         final YangDomElement typeUnderLeaf30domElement = getDomChild(leaf30domElement, CY.TYPE);
 372         assertDomElementHasFindingOfType(typeUnderLeaf30domElement.getChildren().get(0),
 373                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 374         assertDomElementHasFindingOfType(typeUnderLeaf30domElement.getChildren().get(1),
 375                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 376
 377         final YangDomElement leaf31domElement = getDomChild(cont4.getDomElement(), CY.LEAF, "leaf31");
 378         final YangDomElement typeUnderLeaf31domElement = getDomChild(leaf31domElement, CY.TYPE);
 379         assertDomElementHasFindingOfType(typeUnderLeaf31domElement.getChildren().get(0),
 380                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 381         assertDomElementHasFindingOfType(typeUnderLeaf31domElement.getChildren().get(1),
 382                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 383
 384         // - - - - - - some legal and illegal length restrictions - - - - - -
 385
 386         final YContainer cont5 = getContainer(module, "cont5");
 387
 388         assertStatementHasFindingOfType(getLeaf(cont5, "leaf51").getType().getLength(),
 389                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 390         assertStatementHasFindingOfType(getLeaf(cont5, "leaf52").getType().getLength(),
 391                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 392         assertStatementHasFindingOfType(getLeaf(cont5, "leaf53").getType().getLength(),
 393                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 394         assertStatementHasFindingOfType(getLeaf(cont5, "leaf54").getType().getLength(),
 395                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 396         assertStatementHasFindingOfType(getLeaf(cont5, "leaf55").getType().getLength(),
 397                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 398         assertStatementHasFindingOfType(getLeaf(cont5, "leaf56").getType().getLength(),
 399                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 400         assertStatementHasFindingOfType(getLeaf(cont5, "leaf57").getType().getLength(),
 401                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 402         assertStatementHasFindingOfType(getLeaf(cont5, "leaf58").getType().getLength(),
 403                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 404         assertStatementHasFindingOfType(getLeaf(cont5, "leaf59").getType().getLength(),
 405                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 406
 407         assertSubTreeNoFindings(getLeaf(cont5, "leaf61"));
 408         assertSubTreeNoFindings(getLeaf(cont5, "leaf62"));
 409         assertSubTreeNoFindings(getLeaf(cont5, "leaf63"));
 410         assertSubTreeNoFindings(getLeaf(cont5, "leaf64"));
 411         assertSubTreeNoFindings(getLeaf(cont5, "leaf65"));
 412         assertSubTreeNoFindings(getLeaf(cont5, "leaf66"));
 413         assertSubTreeNoFindings(getLeaf(cont5, "leaf67"));
 414         assertSubTreeNoFindings(getLeaf(cont5, "leaf68"));
 415         assertSubTreeNoFindings(getLeaf(cont5, "leaf69"));
 416         assertSubTreeNoFindings(getLeaf(cont5, "leaf70"));
 417         assertSubTreeNoFindings(getLeaf(cont5, "leaf71"));
 418         assertSubTreeNoFindings(getLeaf(cont5, "leaf72"));
 419         assertSubTreeNoFindings(getLeaf(cont5, "leaf73"));
 420
 421         // - - - - - - some legal and illegal range restrictions - - - - - -
 422
 423         final YContainer cont8 = getContainer(module, "cont8");
 424
 425         assertStatementHasFindingOfType(getLeaf(cont8, "leaf81").getType().getRange(),
 426                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 427         assertStatementHasFindingOfType(getLeaf(cont8, "leaf82").getType().getRange(),
 428                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 429         assertStatementHasFindingOfType(getLeaf(cont8, "leaf83").getType().getRange(),
 430                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 431         assertStatementHasFindingOfType(getLeaf(cont8, "leaf84").getType().getRange(),
 432                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 433         assertStatementHasFindingOfType(getLeaf(cont8, "leaf85").getType().getRange(),
 434                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 435         assertStatementHasFindingOfType(getLeaf(cont8, "leaf86").getType().getRange(),
 436                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 437         assertStatementHasFindingOfType(getLeaf(cont8, "leaf87").getType().getRange(),
 438                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 439         assertStatementHasFindingOfType(getLeaf(cont8, "leaf88").getType().getRange(),
 440                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 441         assertStatementHasFindingOfType(getLeaf(cont8, "leaf89").getType().getRange(),
 442                 ParserFindingType.P117_ILLEGAL_DATA_TYPE_RESTRICTION.toString());
 443
 444         assertSubTreeNoFindings(getLeaf(cont8, "leaf91"));
 445         assertSubTreeNoFindings(getLeaf(cont8, "leaf92"));
 446         assertSubTreeNoFindings(getLeaf(cont8, "leaf93"));
 447         assertSubTreeNoFindings(getLeaf(cont8, "leaf94"));
 448     }
 449
 450     private static final String USED_TWICE_NS = "test:typedef-test-used-twice";
 451     private static final String USED_TWICE_MODULE_NAME = "typedef-test-used-twice";
 452
 453     @Test
 454     public void test_Typedef_used_twice() {
 455
 456         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-used-twice.yang"));
 457
 458         final YModule module = getModule("typedef-test-used-twice");
 459
 460         final YContainer cont1 = getContainer(module, "cont1");
 461
 462         final YLeaf leaf2 = getLeaf(cont1, "leaf2");
 463         assertTrue(leaf2.getDefault() != null);
 464         assertTrue(leaf2.getDefault().getValue().equals("10"));
 465         assertOriginalTypedef(leaf2.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 466                 "typedef1"));
 467
 468         final YLeaf leaf3 = getLeaf(cont1, "leaf3");
 469         assertTrue(leaf3.getDefault() != null);
 470         assertTrue(leaf3.getDefault().getValue().equals("5"));
 471         assertOriginalTypedef(leaf3.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 472                 "typedef1"));
 473
 474         final YLeaf leaf4 = getLeaf(cont1, "leaf4");
 475         assertTrue(leaf4.getDefault() != null);
 476         assertTrue(leaf4.getDefault().getValue().equals("5"));
 477         assertOriginalTypedef(leaf4.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 478                 "typedef1"));
 479
 480         final YLeaf leaf5 = getLeaf(cont1, "leaf5");
 481         assertTrue(leaf5.getDefault() != null);
 482         assertTrue(leaf5.getDefault().getValue().equals("20"));
 483         assertOriginalTypedef(leaf5.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 484                 "typedef1"));
 485         assertOriginalTypedef(leaf5.getType(), 1, new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 486                 "typedef2"));
 487
 488         final YLeaf leaf6 = getLeaf(cont1, "leaf6");
 489         assertTrue(leaf6.getDefault() != null);
 490         assertTrue(leaf6.getDefault().getValue().equals("20"));
 491         assertOriginalTypedef(leaf6.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 492                 "typedef1"));
 493         assertOriginalTypedef(leaf6.getType(), 1, new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 494                 "typedef2"));
 495
 496         final YLeaf leaf7 = getLeaf(cont1, "leaf7");
 497         assertTrue(leaf7.getDefault() != null);
 498         assertTrue(leaf7.getDefault().getValue().equals("5"));
 499         assertOriginalTypedef(leaf7.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 500                 "typedef1"));
 501         assertOriginalTypedef(leaf7.getType(), 1, new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 502                 "typedef3"));
 503
 504         final YLeaf leaf8 = getLeaf(cont1, "leaf8");
 505         assertTrue(leaf8.getDefault() != null);
 506         assertTrue(leaf8.getDefault().getValue().equals("5"));
 507         assertOriginalTypedef(leaf8.getType(), new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 508                 "typedef1"));
 509         assertOriginalTypedef(leaf8.getType(), 1, new NamespaceModuleIdentifier(USED_TWICE_NS, USED_TWICE_MODULE_NAME,
 510                 "typedef3"));
 511     }
 512
 513     @Test
 514     public void test_Typedef_nested_union() {
 515
 516         parseRelativeImplementsYangModels(Arrays.asList("typedef-test/typedef-test-nested-union.yang"));
 517
 518         final YModule module = getModule("typedef-test-nested-union-module");
 519
 520         final YContainer cont1 = getContainer(module, "cont1");
 521
 522         final YLeaf leaf11 = getLeaf(cont1, "leaf11");
 523         assertTrue(leaf11.getType().getDataType().equals("union"));
 524         assertTrue(leaf11.getType().getTypes().size() == 2);
 525         assertTrue(leaf11.getType().getTypes().get(0).getDataType().equals("int16"));
 526         assertTrue(leaf11.getType().getTypes().get(1).getDataType().equals("string"));
 527
 528         final YLeaf leaf12 = getLeaf(cont1, "leaf12");
 529         assertTrue(leaf12.getType().getDataType().equals("union"));
 530         assertTrue(leaf12.getType().getTypes().size() == 4);
 531         assertTrue(leaf12.getType().getTypes().get(0).getDataType().equals("int16"));
 532         assertTrue(leaf12.getType().getTypes().get(1).getDataType().equals("string"));
 533         assertTrue(leaf12.getType().getTypes().get(2).getDataType().equals("empty"));
 534         assertTrue(leaf12.getType().getTypes().get(3).getDataType().equals("binary"));
 535
 536         final YLeaf leaf13 = getLeaf(cont1, "leaf13");
 537         assertTrue(leaf13.getType().getDataType().equals("union"));
 538         assertTrue(leaf13.getType().getTypes().size() == 4);
 539         assertTrue(leaf13.getType().getTypes().get(0).getDataType().equals("empty"));
 540         assertTrue(leaf13.getType().getTypes().get(1).getDataType().equals("binary"));
 541         assertTrue(leaf13.getType().getTypes().get(2).getDataType().equals("int16"));
 542         assertTrue(leaf13.getType().getTypes().get(3).getDataType().equals("string"));
 543
 544         final YLeaf leaf14 = getLeaf(cont1, "leaf14");
 545         assertTrue(leaf14.getType().getDataType().equals("union"));
 546         assertTrue(leaf14.getType().getTypes().size() == 4);
 547         assertTrue(leaf14.getType().getTypes().get(0).getDataType().equals("int16"));
 548         assertTrue(leaf14.getType().getTypes().get(1).getDataType().equals("empty"));
 549         assertTrue(leaf14.getType().getTypes().get(2).getDataType().equals("binary"));
 550         assertTrue(leaf14.getType().getTypes().get(3).getDataType().equals("string"));
 551
 552         final YLeaf leaf15 = getLeaf(cont1, "leaf15");
 553         assertTrue(leaf15.getType().getDataType().equals("union"));
 554         assertTrue(leaf15.getType().getTypes().size() == 6);
 555         assertTrue(leaf15.getType().getTypes().get(0).getDataType().equals("int16"));
 556         assertTrue(leaf15.getType().getTypes().get(1).getDataType().equals("empty"));
 557         assertTrue(leaf15.getType().getTypes().get(2).getDataType().equals("int32"));
 558         assertTrue(leaf15.getType().getTypes().get(3).getDataType().equals("boolean"));
 559         assertTrue(leaf15.getType().getTypes().get(4).getDataType().equals("binary"));
 560         assertTrue(leaf15.getType().getTypes().get(5).getDataType().equals("string"));
 561
 562         final YContainer cont2 = getContainer(module, "cont2");
 563
 564         final YLeaf leaf21 = getLeaf(cont2, "leaf21");
 565         assertTrue(leaf21.getType().getDataType().equals("union"));
 566         assertTrue(leaf21.getType().getTypes().size() == 2);
 567         assertTrue(leaf21.getType().getTypes().get(0).getDataType().equals("binary"));
 568         assertTrue(leaf21.getType().getTypes().get(1).getDataType().equals("empty"));
 569
 570         final YLeaf leaf22 = getLeaf(cont2, "leaf22");
 571         assertTrue(leaf22.getType().getDataType().equals("union"));
 572         assertTrue(leaf22.getType().getTypes().size() == 3);
 573         assertTrue(leaf22.getType().getTypes().get(0).getDataType().equals("uint64"));
 574         assertTrue(leaf22.getType().getTypes().get(1).getDataType().equals("binary"));
 575         assertTrue(leaf22.getType().getTypes().get(2).getDataType().equals("empty"));
 576
 577         final YLeaf leaf23 = getLeaf(cont2, "leaf23");
 578         assertTrue(leaf23.getType().getDataType().equals("union"));
 579         assertTrue(leaf23.getType().getTypes().size() == 3);
 580         assertTrue(leaf23.getType().getTypes().get(0).getDataType().equals("binary"));
 581         assertTrue(leaf23.getType().getTypes().get(1).getDataType().equals("empty"));
 582         assertTrue(leaf23.getType().getTypes().get(2).getDataType().equals("uint64"));
 583
 584         final YLeaf leaf24 = getLeaf(cont2, "leaf24");
 585         assertTrue(leaf24.getType().getDataType().equals("union"));
 586         assertTrue(leaf24.getType().getTypes().size() == 1);
 587         assertTrue(leaf24.getType().getTypes().get(0).getDataType().equals("int32"));
 588
 589         final YLeaf leaf25 = getLeaf(cont2, "leaf25");
 590         assertTrue(leaf25.getType().getDataType().equals("union"));
 591         assertTrue(leaf25.getType().getTypes().size() == 2);
 592         assertTrue(leaf25.getType().getTypes().get(0).getDataType().equals("uint64"));
 593         assertTrue(leaf25.getType().getTypes().get(1).getDataType().equals("int32"));
 594
 595         final YLeaf leaf26 = getLeaf(cont2, "leaf26");
 596         assertTrue(leaf26.getType().getDataType().equals("union"));
 597         assertTrue(leaf26.getType().getTypes().size() == 3);
 598         assertTrue(leaf26.getType().getTypes().get(0).getDataType().equals("boolean"));
 599         assertTrue(leaf26.getType().getTypes().get(1).getDataType().equals("binary"));
 600         assertTrue(leaf26.getType().getTypes().get(2).getDataType().equals("empty"));
 601
 602         final YLeaf leaf27 = getLeaf(cont2, "leaf27");
 603         assertTrue(leaf27.getType().getDataType().equals("union"));
 604         assertTrue(leaf27.getType().getTypes().size() == 4);
 605         assertTrue(leaf27.getType().getTypes().get(0).getDataType().equals("boolean"));
 606         assertTrue(leaf27.getType().getTypes().get(1).getDataType().equals("binary"));
 607         assertTrue(leaf27.getType().getTypes().get(2).getDataType().equals("empty"));
 608         assertTrue(leaf27.getType().getTypes().get(3).getDataType().equals("uint64"));
 609
 610         final YLeaf leaf28 = getLeaf(cont2, "leaf28");
 611         assertTrue(leaf28.getType().getDataType().equals("union"));
 612         assertTrue(leaf28.getType().getTypes().size() == 6);
 613         assertTrue(leaf28.getType().getTypes().get(0).getDataType().equals("uint64"));
 614         assertTrue(leaf28.getType().getTypes().get(1).getDataType().equals("boolean"));
 615         assertTrue(leaf28.getType().getTypes().get(2).getDataType().equals("binary"));
 616         assertTrue(leaf28.getType().getTypes().get(3).getDataType().equals("empty"));
 617         assertTrue(leaf28.getType().getTypes().get(4).getDataType().equals("int32"));
 618         assertTrue(leaf28.getType().getTypes().get(5).getDataType().equals("string"));
 619     }
 620
 621     private static void assertOriginalTypedefStackSize(final YType yType, final int size) {
 622         assertEquals(size, TypeResolver.getTypedefStack(yType).size());
 623     }
 624
 625     private static void assertOriginalTypedef(final YType yType, final NamespaceModuleIdentifier soughtTypedefIdentity) {
 626         assertOriginalTypedef(yType, 0, soughtTypedefIdentity);
 627     }
 628
 629     private static void assertOriginalTypedef(final YType yType, final int index,
 630             final NamespaceModuleIdentifier soughtTypedefIdentity) {
 631
 632         final List<NamespaceModuleIdentifier> stack = TypeResolver.getTypedefStack(yType);
 633         if (index >= stack.size()) {
 634             fail("Typedef stack index " + index + " does not exist.");
 635         }
 636
 637         final NamespaceModuleIdentifier nsai = stack.get(index);
 638         if (!nsai.toString().equals(soughtTypedefIdentity.toString())) {
 639             fail("Expected '" + soughtTypedefIdentity + "' but got '" + nsai + "'.");
 640         }
 641     }
 642 }