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.assertFalse;
  25 import static org.junit.Assert.assertTrue;
  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.statements.AbstractStatement.StatementArgumentType;
  35 import org.oran.smo.yangtools.parser.model.statements.yang.CY;
  36 import org.oran.smo.yangtools.parser.model.statements.yang.YCase;
  37 import org.oran.smo.yangtools.parser.model.statements.yang.YChoice;
  38 import org.oran.smo.yangtools.parser.model.statements.yang.YContainer;
  39 import org.oran.smo.yangtools.parser.model.statements.yang.YLeaf;
  40 import org.oran.smo.yangtools.parser.model.statements.yang.YLength;
  41 import org.oran.smo.yangtools.parser.model.statements.yang.YList;
  42 import org.oran.smo.yangtools.parser.model.statements.yang.YLength.BoundaryPair;
  43 import org.oran.smo.yangtools.parser.testutils.YangTestCommon;
  44 import org.oran.smo.yangtools.parser.model.statements.yang.YModule;
  45 import org.oran.smo.yangtools.parser.model.statements.yang.YOrderedBy;
  46 import org.oran.smo.yangtools.parser.model.statements.yang.YRange;
  47 import org.oran.smo.yangtools.parser.model.statements.yang.YRpc;
  48
  49 public class GeneralSyntaxTest extends YangTestCommon {
  50
  51     @Test
  52     public void testGeneralSyntaxRpc() {
  53
  54         severityCalculator.suppressFinding(ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY.toString());
  55         severityCalculator.suppressFinding(ParserFindingType.P133_GROUPING_USED_ONCE_ONLY.toString());
  56         severityCalculator.suppressFinding(ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
  57
  58         parseRelativeImplementsYangModels(Arrays.asList("general-syntax-test/general-syntax-test-rpc.yang"));
  59
  60         assertNoFindings();
  61
  62         final YModule yModule = getModule("general-syntax-test-rpc");
  63         assertTrue(yModule != null);
  64
  65         // -------------- RPCs -------------------
  66
  67         final YRpc rpc1 = getChild(yModule, CY.RPC, "rpc1");
  68         assertTrue(rpc1 != null);
  69
  70         final YRpc rpc2 = getChild(yModule, CY.RPC, "rpc2");
  71         assertTrue(rpc2 != null);
  72         assertTrue(rpc2.getInput() != null);
  73         assertTrue(rpc2.getOutput() != null);           // missing in YAM, auto-created by parser
  74         assertTrue(rpc2.getInput().getContainers().get(0) != null);
  75         assertTrue(rpc2.getInput().getContainers().get(0).getStatementIdentifier().equals("cont1"));
  76
  77         final YRpc rpc3 = getChild(yModule, CY.RPC, "rpc3");
  78         assertTrue(rpc3 != null);
  79         assertTrue(rpc3.getInput() != null);            // missing in YAM, auto-created by parser
  80         assertTrue(rpc3.getOutput() != null);
  81         assertTrue(rpc3.getOutput().getContainers().get(0) != null);
  82         assertTrue(rpc3.getOutput().getContainers().get(0).getStatementIdentifier().equals("cont2"));
  83
  84         final YRpc rpc4 = getChild(yModule, CY.RPC, "rpc4");
  85         assertTrue(rpc4 != null);
  86         assertTrue(rpc4.getStatus() != null);
  87         assertTrue(rpc4.getStatus().isDeprecated());
  88         assertTrue(rpc4.getIfFeatures().get(0) != null);
  89         assertTrue(rpc4.getIfFeatures().get(0).getValue().equals("feature1"));
  90         assertTrue(rpc4.getTypedefs().get(0) != null);
  91         assertTrue(rpc4.getTypedefs().get(0).getTypedefName().equals("typedef1"));
  92         assertTrue(rpc4.getGroupings().get(0) != null);
  93         assertTrue(rpc4.getGroupings().get(0).getGroupingName().equals("grouping1"));
  94
  95         assertTrue(rpc4.getOutput() != null);
  96         assertTrue(rpc4.getOutput().getLeafs().get(0) != null);
  97         assertTrue(rpc4.getOutput().getLeafs().get(0).getType().getDataType().equals("string"));
  98         assertTrue(rpc4.getOutput().getAnyxmls().get(0) != null);
  99         assertTrue(rpc4.getOutput().getAnyxmls().get(0).getStatementIdentifier().equals("anyxml1"));
 100         assertTrue(rpc4.getOutput().getAnydata().get(0) != null);
 101         assertTrue(rpc4.getOutput().getAnydata().get(0).getStatementIdentifier().equals("anydata1"));
 102         assertTrue(rpc4.getOutput().getLists().get(0) != null);
 103         assertTrue(rpc4.getOutput().getLists().get(0).getStatementIdentifier().equals("list1"));
 104         assertTrue(rpc4.getOutput().getLeafLists().get(0) != null);
 105         assertTrue(rpc4.getOutput().getLeafLists().get(0).getStatementIdentifier().equals("leaflist3"));
 106         assertTrue(rpc4.getOutput().getChoices().get(0) != null);
 107         assertTrue(rpc4.getOutput().getChoices().get(0).getStatementIdentifier().equals("choice1"));
 108         assertTrue(rpc4.getOutput().getMusts().get(0) != null);
 109         assertTrue(rpc4.getOutput().getMusts().get(0).getXpathExpression().equals("../contX"));
 110         assertTrue(rpc4.getOutput().getTypedefs().get(0) != null);
 111         assertTrue(rpc4.getOutput().getTypedefs().get(0).getTypedefName().equals("typedef2"));
 112
 113         assertTrue(rpc4.getInput() != null);
 114         assertTrue(rpc4.getInput().getContainers().get(0) != null);
 115         assertTrue(rpc4.getInput().getContainers().get(0).getContainerName().equals("cont4"));
 116         assertTrue(rpc4.getInput().getLeafs().get(0) != null);
 117         assertTrue(rpc4.getInput().getLeafs().get(0).getLeafName().equals("grouping-leaf"));
 118         assertTrue(rpc4.getInput().getAnyxmls().get(0) != null);
 119         assertTrue(rpc4.getInput().getAnyxmls().get(0).getStatementIdentifier().equals("anyxml1"));
 120         assertTrue(rpc4.getInput().getAnydata().get(0) != null);
 121         assertTrue(rpc4.getInput().getAnydata().get(0).getStatementIdentifier().equals("anydata1"));
 122         assertTrue(rpc4.getInput().getLists().get(0) != null);
 123         assertTrue(rpc4.getInput().getLists().get(0).getStatementIdentifier().equals("list1"));
 124         assertTrue(rpc4.getInput().getLeafLists().get(0) != null);
 125         assertTrue(rpc4.getInput().getLeafLists().get(0).getStatementIdentifier().equals("leaflist3"));
 126         assertTrue(rpc4.getInput().getChoices().get(0) != null);
 127         assertTrue(rpc4.getInput().getChoices().get(0).getStatementIdentifier().equals("choice1"));
 128         assertTrue(rpc4.getInput().getMusts().get(0) != null);
 129         assertTrue(rpc4.getInput().getMusts().get(0).getXpathExpression().equals("../contX"));
 130         assertTrue(rpc4.getInput().getTypedefs().get(0) != null);
 131         assertTrue(rpc4.getInput().getTypedefs().get(0).getTypedefName().equals("typedef2"));
 132     }
 133
 134     @Test
 135     public void testGeneralSyntaxConstraints() {
 136
 137         severityCalculator.suppressFinding(ParserFindingType.P115_TYPEDEF_USED_ONCE_ONLY.toString());
 138         severityCalculator.suppressFinding(ParserFindingType.P133_GROUPING_USED_ONCE_ONLY.toString());
 139
 140         parseRelativeImplementsYangModels(Arrays.asList("general-syntax-test/general-syntax-test-constraints.yang"));
 141
 142         final YModule module = getModule("general-syntax-test-constraints");
 143         assertTrue(module != null);
 144
 145         // -------------- Length -------------------
 146
 147         {
 148             final YContainer cont1 = getContainer(module, "cont1");
 149
 150             final YLeaf leaf1 = getLeaf(cont1, "leaf1");
 151             final YLength length1 = leaf1.getType().getLength();
 152
 153             assertTrue(length1.getErrorAppTag() != null);
 154             assertTrue(length1.getErrorAppTag().getValue().equals("some-app-tag"));
 155             assertTrue(length1.getErrorMessage() != null);
 156             assertTrue(length1.getErrorMessage().getValue().equals("wrong length"));
 157             assertNoFindingsOnStatement(getLeaf(cont1, "leaf1").getType().getLength());
 158
 159             final List<BoundaryPair> boundaries1 = length1.getBoundaries();
 160             assertTrue(boundaries1.size() == 1);
 161             assertTrue(boundaries1.get(0).lower == 1L);
 162             assertTrue(boundaries1.get(0).upper == 10L);
 163
 164             final List<BoundaryPair> boundaries2 = getLeaf(cont1, "leaf2").getType().getLength().getBoundaries();
 165             assertTrue(boundaries2.size() == 1);
 166             assertTrue(boundaries2.get(0).lower == 0L);
 167             assertTrue(boundaries2.get(0).upper == Long.MAX_VALUE);
 168             assertNoFindingsOnStatement(getLeaf(cont1, "leaf2").getType().getLength());
 169
 170             final List<BoundaryPair> boundaries3 = getLeaf(cont1, "leaf3").getType().getLength().getBoundaries();
 171             assertTrue(boundaries3.size() == 3);
 172             assertTrue(boundaries3.get(0).lower == 0L);
 173             assertTrue(boundaries3.get(0).upper == 10L);
 174             assertTrue(boundaries3.get(1).lower == 15L);
 175             assertTrue(boundaries3.get(1).upper == 15L);
 176             assertTrue(boundaries3.get(2).lower == 20L);
 177             assertTrue(boundaries3.get(2).upper == Long.MAX_VALUE);
 178             assertNoFindingsOnStatement(getLeaf(cont1, "leaf3").getType().getLength());
 179
 180             assertTrue(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(0));
 181             assertTrue(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(10));
 182             assertTrue(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(15));
 183             assertTrue(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(20));
 184             assertTrue(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(40404040404L));
 185
 186             assertFalse(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(-1));
 187             assertFalse(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(11));
 188             assertFalse(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(14));
 189             assertFalse(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(16));
 190             assertFalse(getLeaf(cont1, "leaf3").getType().getLength().isWithinLengthBoundaries(19));
 191
 192             final List<BoundaryPair> boundaries4 = getLeaf(cont1, "leaf4").getType().getLength().getBoundaries();
 193             assertTrue(boundaries4.size() == 2);
 194             assertTrue(boundaries4.get(0).lower == 0L);
 195             assertTrue(boundaries4.get(0).upper == 0L);
 196             assertTrue(boundaries4.get(1).lower == Long.MAX_VALUE);
 197             assertTrue(boundaries4.get(1).upper == Long.MAX_VALUE);
 198             assertNoFindingsOnStatement(getLeaf(cont1, "leaf4").getType().getLength());
 199
 200             final List<BoundaryPair> boundaries5 = getLeaf(cont1, "leaf5").getType().getLength().getBoundaries();
 201             assertTrue(boundaries5.size() == 0);
 202             assertStatementHasFindingOfType(getLeaf(cont1, "leaf5").getType().getLength(),
 203                     ParserFindingType.P053_INVALID_VALUE.toString());
 204
 205             final List<BoundaryPair> boundaries6 = getLeaf(cont1, "leaf6").getType().getLength().getBoundaries();
 206             assertTrue(boundaries6.size() == 0);
 207             assertStatementHasFindingOfType(getLeaf(cont1, "leaf6").getType().getLength(),
 208                     ParserFindingType.P053_INVALID_VALUE.toString());
 209
 210             final List<BoundaryPair> boundaries7 = getLeaf(cont1, "leaf7").getType().getLength().getBoundaries();
 211             assertTrue(boundaries7.size() == 0);
 212             assertStatementHasFindingOfType(getLeaf(cont1, "leaf7").getType().getLength(),
 213                     ParserFindingType.P053_INVALID_VALUE.toString());
 214
 215             final List<BoundaryPair> boundaries8 = getLeaf(cont1, "leaf8").getType().getLength().getBoundaries();
 216             assertTrue(boundaries8.size() == 2);
 217             assertTrue(boundaries8.get(0).lower == 10L);
 218             assertTrue(boundaries8.get(0).upper == 20L);
 219             assertTrue(boundaries8.get(1).lower == 21L);
 220             assertTrue(boundaries8.get(1).upper == 30L);
 221             assertNoFindingsOnStatement(getLeaf(cont1, "leaf8").getType().getLength());
 222
 223             final List<BoundaryPair> boundaries9 = getLeaf(cont1, "leaf9").getType().getLength().getBoundaries();
 224             assertTrue(boundaries9.size() == 2);
 225             assertTrue(boundaries9.get(0).lower == 10L);
 226             assertTrue(boundaries9.get(0).upper == 20L);
 227             assertTrue(boundaries9.get(1).lower == 20L);
 228             assertTrue(boundaries9.get(1).upper == 30L);
 229             assertStatementHasFindingOfType(getLeaf(cont1, "leaf9").getType().getLength(),
 230                     ParserFindingType.P053_INVALID_VALUE.toString());
 231
 232             final List<BoundaryPair> boundaries10 = getLeaf(cont1, "leaf10").getType().getLength().getBoundaries();
 233             assertTrue(boundaries10.size() == 2);
 234             assertTrue(boundaries10.get(0).lower == 19L);
 235             assertTrue(boundaries10.get(0).upper == 30L);
 236             assertTrue(boundaries10.get(1).lower == 10L);
 237             assertTrue(boundaries10.get(1).upper == 20L);
 238             assertStatementHasFindingOfType(getLeaf(cont1, "leaf10").getType().getLength(),
 239                     ParserFindingType.P053_INVALID_VALUE.toString());
 240
 241             final List<BoundaryPair> boundaries11 = getLeaf(cont1, "leaf11").getType().getLength().getBoundaries();
 242             assertTrue(boundaries11.size() == 1);
 243             assertTrue(boundaries11.get(0).lower == -1L);
 244             assertTrue(boundaries11.get(0).upper == -3L);
 245             assertStatementHasFindingOfType(getLeaf(cont1, "leaf11").getType().getLength(),
 246                     ParserFindingType.P053_INVALID_VALUE.toString());
 247
 248             final List<BoundaryPair> boundaries12 = getLeaf(cont1, "leaf12").getType().getLength().getBoundaries();
 249             assertTrue(boundaries12.size() == 0);
 250             assertStatementHasFindingOfType(getLeaf(cont1, "leaf12").getType().getLength(),
 251                     ParserFindingType.P053_INVALID_VALUE.toString());
 252
 253             final List<BoundaryPair> boundaries13 = getLeaf(cont1, "leaf13").getType().getLength().getBoundaries();
 254             assertTrue(boundaries13.size() == 0);
 255             assertStatementHasFindingOfType(getLeaf(cont1, "leaf13").getType().getLength(),
 256                     ParserFindingType.P053_INVALID_VALUE.toString());
 257         }
 258
 259         // -------------- Range for integer -------------------
 260
 261         {
 262             final YContainer cont2 = getContainer(module, "cont2");
 263             assertTrue(cont2 != null);
 264
 265             final YLeaf leaf1 = getLeaf(cont2, "leaf1");
 266             assertTrue(leaf1 != null);
 267             final YRange range1 = leaf1.getType().getRange();
 268             assertTrue(range1 != null);
 269
 270             assertTrue(range1.getErrorAppTag() != null);
 271             assertTrue(range1.getErrorAppTag().getValue().equals("some-app-tag"));
 272             assertTrue(range1.getErrorMessage() != null);
 273             assertTrue(range1.getErrorMessage().getValue().equals("wrong length"));
 274             assertNoFindingsOnStatement(getLeaf(cont2, "leaf1").getType().getRange());
 275
 276             final List<YRange.BoundaryPair> boundaries1 = range1.getBoundaries();
 277             assertTrue(boundaries1.size() == 1);
 278             assertTrue(boundaries1.get(0).lower.compareTo(BigDecimal.valueOf(1L)) == 0);
 279             assertTrue(boundaries1.get(0).upper.compareTo(BigDecimal.valueOf(10L)) == 0);
 280             assertNoFindingsOnStatement(getLeaf(cont2, "leaf1").getType().getRange());
 281
 282             assertTrue(getLeaf(cont2, "leaf1").getType().getRange().isWithinRangeBoundaries(BigDecimal.valueOf(5L)));
 283             assertFalse(getLeaf(cont2, "leaf1").getType().getRange().isWithinRangeBoundaries(BigDecimal.valueOf(-20L)));
 284             assertFalse(getLeaf(cont2, "leaf1").getType().getRange().isWithinRangeBoundaries(BigDecimal.valueOf(90L)));
 285
 286             final List<YRange.BoundaryPair> boundaries2 = getLeaf(cont2, "leaf2").getType().getRange().getBoundaries();
 287             assertTrue(boundaries2.get(0).lower.compareTo(BigDecimal.valueOf(0L)) == 0);
 288             assertTrue(boundaries2.get(0).upper.compareTo(BigDecimal.valueOf(255L)) == 0);
 289             assertNoFindingsOnStatement(getLeaf(cont2, "leaf2").getType().getRange());
 290
 291             final List<YRange.BoundaryPair> boundaries3 = getLeaf(cont2, "leaf3").getType().getRange().getBoundaries();
 292             assertTrue(boundaries3.get(0).lower.compareTo(BigDecimal.valueOf(0L)) == 0);
 293             assertTrue(boundaries3.get(0).upper.compareTo(BigDecimal.valueOf(65535L)) == 0);
 294             assertNoFindingsOnStatement(getLeaf(cont2, "leaf3").getType().getRange());
 295
 296             final List<YRange.BoundaryPair> boundaries4 = getLeaf(cont2, "leaf4").getType().getRange().getBoundaries();
 297             assertTrue(boundaries4.get(0).lower.compareTo(BigDecimal.valueOf(0L)) == 0);
 298             assertTrue(boundaries4.get(0).upper.compareTo(BigDecimal.valueOf(4294967295L)) == 0);
 299             assertNoFindingsOnStatement(getLeaf(cont2, "leaf4").getType().getRange());
 300
 301             final List<YRange.BoundaryPair> boundaries5 = getLeaf(cont2, "leaf5").getType().getRange().getBoundaries();
 302             assertTrue(boundaries5.get(0).lower.compareTo(BigDecimal.valueOf(0L)) == 0);
 303             assertTrue(boundaries5.get(0).upper.compareTo(new BigDecimal("18446744073709551615")) == 0);
 304             assertNoFindingsOnStatement(getLeaf(cont2, "leaf5").getType().getRange());
 305
 306             final List<YRange.BoundaryPair> boundaries6 = getLeaf(cont2, "leaf6").getType().getRange().getBoundaries();
 307             assertTrue(boundaries6.get(0).lower.compareTo(BigDecimal.valueOf(-128L)) == 0);
 308             assertTrue(boundaries6.get(0).upper.compareTo(BigDecimal.valueOf(127L)) == 0);
 309             assertNoFindingsOnStatement(getLeaf(cont2, "leaf6").getType().getRange());
 310
 311             final List<YRange.BoundaryPair> boundaries7 = getLeaf(cont2, "leaf7").getType().getRange().getBoundaries();
 312             assertTrue(boundaries7.get(0).lower.compareTo(BigDecimal.valueOf(-32768L)) == 0);
 313             assertTrue(boundaries7.get(0).upper.compareTo(BigDecimal.valueOf(32767L)) == 0);
 314             assertNoFindingsOnStatement(getLeaf(cont2, "leaf7").getType().getRange());
 315
 316             final List<YRange.BoundaryPair> boundaries8 = getLeaf(cont2, "leaf8").getType().getRange().getBoundaries();
 317             assertTrue(boundaries8.get(0).lower.compareTo(BigDecimal.valueOf(-2147483648L)) == 0);
 318             assertTrue(boundaries8.get(0).upper.compareTo(BigDecimal.valueOf(2147483647L)) == 0);
 319             assertNoFindingsOnStatement(getLeaf(cont2, "leaf8").getType().getRange());
 320
 321             final List<YRange.BoundaryPair> boundaries9 = getLeaf(cont2, "leaf9").getType().getRange().getBoundaries();
 322             assertTrue(boundaries9.get(0).lower.compareTo(BigDecimal.valueOf(-9223372036854775808L)) == 0);
 323             assertTrue(boundaries9.get(0).upper.compareTo(BigDecimal.valueOf(9223372036854775807L)) == 0);
 324             assertNoFindingsOnStatement(getLeaf(cont2, "leaf9").getType().getRange());
 325
 326             final List<YRange.BoundaryPair> boundaries10 = getLeaf(cont2, "leaf10").getType().getRange().getBoundaries();
 327             assertTrue(boundaries10.size() == 1);
 328             assertTrue(boundaries10.get(0).lower.compareTo(BigDecimal.valueOf(10L)) == 0);
 329             assertTrue(boundaries10.get(0).upper.compareTo(BigDecimal.valueOf(20L)) == 0);
 330             assertNoFindingsOnStatement(getLeaf(cont2, "leaf10").getType().getRange());
 331
 332             final List<YRange.BoundaryPair> boundaries11 = getLeaf(cont2, "leaf11").getType().getRange().getBoundaries();
 333             assertTrue(boundaries11.size() == 2);
 334             assertTrue(boundaries11.get(0).lower.compareTo(BigDecimal.valueOf(10L)) == 0);
 335             assertTrue(boundaries11.get(0).upper.compareTo(BigDecimal.valueOf(20L)) == 0);
 336             assertTrue(boundaries11.get(1).lower.compareTo(BigDecimal.valueOf(30L)) == 0);
 337             assertTrue(boundaries11.get(1).upper.compareTo(BigDecimal.valueOf(40L)) == 0);
 338             assertNoFindingsOnStatement(getLeaf(cont2, "leaf11").getType().getRange());
 339
 340             final List<YRange.BoundaryPair> boundaries12 = getLeaf(cont2, "leaf12").getType().getRange().getBoundaries();
 341             assertTrue(boundaries12.size() == 3);
 342             assertTrue(boundaries12.get(0).lower.compareTo(BigDecimal.valueOf(10L)) == 0);
 343             assertTrue(boundaries12.get(0).upper.compareTo(BigDecimal.valueOf(20L)) == 0);
 344             assertTrue(boundaries12.get(1).lower.compareTo(BigDecimal.valueOf(25L)) == 0);
 345             assertTrue(boundaries12.get(1).upper.compareTo(BigDecimal.valueOf(25L)) == 0);
 346             assertTrue(boundaries12.get(2).lower.compareTo(BigDecimal.valueOf(30L)) == 0);
 347             assertTrue(boundaries12.get(2).upper.compareTo(BigDecimal.valueOf(40L)) == 0);
 348             assertNoFindingsOnStatement(getLeaf(cont2, "leaf12").getType().getRange());
 349
 350             final List<YRange.BoundaryPair> boundaries13 = getLeaf(cont2, "leaf13").getType().getRange().getBoundaries();
 351             assertTrue(boundaries13.size() == 2);
 352             assertTrue(boundaries13.get(0).lower.compareTo(BigDecimal.valueOf(0L)) == 0);
 353             assertTrue(boundaries13.get(0).upper.compareTo(BigDecimal.valueOf(0L)) == 0);
 354             assertTrue(boundaries13.get(1).lower.compareTo(BigDecimal.valueOf(255L)) == 0);
 355             assertTrue(boundaries13.get(1).upper.compareTo(BigDecimal.valueOf(255L)) == 0);
 356             assertNoFindingsOnStatement(getLeaf(cont2, "leaf13").getType().getRange());
 357
 358             final List<YRange.BoundaryPair> boundaries14 = getLeaf(cont2, "leaf14").getType().getRange().getBoundaries();
 359             assertTrue(boundaries14.size() == 0);
 360             assertStatementHasFindingOfType(getLeaf(cont2, "leaf14").getType().getRange(),
 361                     ParserFindingType.P053_INVALID_VALUE.toString());
 362
 363             final List<YRange.BoundaryPair> boundaries15 = getLeaf(cont2, "leaf15").getType().getRange().getBoundaries();
 364             assertTrue(boundaries15.size() == 0);
 365             assertStatementHasFindingOfType(getLeaf(cont2, "leaf15").getType().getRange(),
 366                     ParserFindingType.P053_INVALID_VALUE.toString());
 367
 368             final List<YRange.BoundaryPair> boundaries16 = getLeaf(cont2, "leaf16").getType().getRange().getBoundaries();
 369             assertTrue(boundaries16.size() == 0);
 370             assertStatementHasFindingOfType(getLeaf(cont2, "leaf16").getType().getRange(),
 371                     ParserFindingType.P053_INVALID_VALUE.toString());
 372
 373             final List<YRange.BoundaryPair> boundaries17 = getLeaf(cont2, "leaf17").getType().getRange().getBoundaries();
 374             assertTrue(boundaries17.size() == 0);
 375             assertStatementHasFindingOfType(getLeaf(cont2, "leaf17").getType().getRange(),
 376                     ParserFindingType.P053_INVALID_VALUE.toString());
 377
 378             final List<YRange.BoundaryPair> boundaries18 = getLeaf(cont2, "leaf18").getType().getRange().getBoundaries();
 379             assertTrue(boundaries18.size() == 0);
 380             assertStatementHasFindingOfType(getLeaf(cont2, "leaf18").getType().getRange(),
 381                     ParserFindingType.P053_INVALID_VALUE.toString());
 382
 383             final List<YRange.BoundaryPair> boundaries19 = getLeaf(cont2, "leaf19").getType().getRange().getBoundaries();
 384             assertTrue(boundaries19.size() == 2);
 385             assertStatementHasFindingOfType(getLeaf(cont2, "leaf19").getType().getRange(),
 386                     ParserFindingType.P053_INVALID_VALUE.toString());
 387
 388             final List<YRange.BoundaryPair> boundaries20 = getLeaf(cont2, "leaf20").getType().getRange().getBoundaries();
 389             assertTrue(boundaries20.size() == 2);
 390             assertStatementHasFindingOfType(getLeaf(cont2, "leaf20").getType().getRange(),
 391                     ParserFindingType.P053_INVALID_VALUE.toString());
 392
 393             final List<YRange.BoundaryPair> boundaries21 = getLeaf(cont2, "leaf21").getType().getRange().getBoundaries();
 394             assertTrue(boundaries21.size() == 2);
 395             assertStatementHasFindingOfType(getLeaf(cont2, "leaf21").getType().getRange(),
 396                     ParserFindingType.P053_INVALID_VALUE.toString());
 397
 398             final List<YRange.BoundaryPair> boundaries22 = getLeaf(cont2, "leaf22").getType().getRange().getBoundaries();
 399             assertTrue(boundaries22.size() == 2);
 400             assertStatementHasFindingOfType(getLeaf(cont2, "leaf22").getType().getRange(),
 401                     ParserFindingType.P053_INVALID_VALUE.toString());
 402
 403             final List<YRange.BoundaryPair> boundaries23 = getLeaf(cont2, "leaf23").getType().getRange().getBoundaries();
 404             assertTrue(boundaries23.size() == 2);
 405             assertStatementHasFindingOfType(getLeaf(cont2, "leaf23").getType().getRange(),
 406                     ParserFindingType.P053_INVALID_VALUE.toString());
 407
 408             final List<YRange.BoundaryPair> boundaries24 = getLeaf(cont2, "leaf24").getType().getRange().getBoundaries();
 409             assertTrue(boundaries24.size() == 1);
 410             assertStatementHasFindingOfType(getLeaf(cont2, "leaf24").getType().getRange(),
 411                     ParserFindingType.P053_INVALID_VALUE.toString());
 412
 413             final List<YRange.BoundaryPair> boundaries25 = getLeaf(cont2, "leaf25").getType().getRange().getBoundaries();
 414             assertTrue(boundaries25.size() == 0);
 415             assertStatementHasFindingOfType(getLeaf(cont2, "leaf25").getType().getRange(),
 416                     ParserFindingType.P018_ILLEGAL_CHILD_STATEMENT.toString());
 417         }
 418
 419         // -------------- Range for decimal64 -------------------
 420
 421         {
 422             final YContainer cont3 = getContainer(module, "cont3");
 423             assertTrue(cont3 != null);
 424
 425             final YLeaf leaf1 = getLeaf(cont3, "leaf1");
 426             assertTrue(leaf1 != null);
 427             final YRange range1 = leaf1.getType().getRange();
 428             assertTrue(range1 != null);
 429
 430             final List<YRange.BoundaryPair> boundaries1 = range1.getBoundaries();
 431             assertTrue(boundaries1.size() == 1);
 432             assertTrue(boundaries1.get(0).lower.compareTo(new BigDecimal("-922337203685477580.8")) == 0);
 433             assertTrue(boundaries1.get(0).upper.compareTo(new BigDecimal("922337203685477580.7")) == 0);
 434             assertNoFindingsOnStatement(getLeaf(cont3, "leaf1").getType().getRange());
 435
 436             final List<YRange.BoundaryPair> boundaries2 = getLeaf(cont3, "leaf2").getType().getRange().getBoundaries();
 437             assertTrue(boundaries2.get(0).lower.compareTo(new BigDecimal("-9.223372036854775808")) == 0);
 438             assertTrue(boundaries2.get(0).upper.compareTo(new BigDecimal("9.223372036854775807")) == 0);
 439             assertNoFindingsOnStatement(getLeaf(cont3, "leaf2").getType().getRange());
 440
 441             final List<YRange.BoundaryPair> boundaries3 = getLeaf(cont3, "leaf3").getType().getRange().getBoundaries();
 442             assertTrue(boundaries3.size() == 0);
 443             assertNoFindingsOnStatement(getLeaf(cont3, "leaf3").getType().getRange());
 444         }
 445     }
 446
 447     @Test
 448     public void testGeneralVarious() {
 449
 450         severityCalculator.suppressFinding(ParserFindingType.P132_GROUPING_NOT_USED.toString());
 451         severityCalculator.suppressFinding(ParserFindingType.P114_TYPEDEF_NOT_USED.toString());
 452         severityCalculator.suppressFinding(ParserFindingType.P143_ENUM_WITHOUT_VALUE.toString());
 453
 454         parseRelativeImplementsYangModels(Arrays.asList("general-syntax-test/general-syntax-test-various.yang"));
 455
 456         final YModule module = getModule("general-syntax-test-various");
 457         assertTrue(module != null);
 458
 459         // - - - - enums - - - - -
 460
 461         final YContainer cont1 = getContainer(module, "cont1");
 462
 463         final YLeaf leaf1 = getLeaf(cont1, "leaf1");
 464
 465         assertNoFindingsOnStatement(leaf1.getType().getEnums().get(0));
 466         assertNoFindingsOnStatement(leaf1.getType().getEnums().get(1));
 467         assertNoFindingsOnStatement(leaf1.getType().getEnums().get(2));
 468         assertStatementHasFindingOfType(leaf1.getType().getEnums().get(3), ParserFindingType.P141_WHITESPACE_IN_ENUM
 469                 .toString());
 470         assertNoFindingsOnStatement(leaf1.getType().getEnums().get(4));
 471         assertStatementHasFindingOfType(leaf1.getType().getEnums().get(5), ParserFindingType.P142_UNUSUAL_CHARACTERS_IN_ENUM
 472                 .toString());
 473         assertStatementHasFindingOfType(leaf1.getType().getEnums().get(6).getValue(),
 474                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 475         assertTrue(leaf1.getType().getEnums().get(6).getValue().getEnumValue() == 0);
 476
 477         assertTrue(leaf1.getType().getEnums().get(0).getValue().getValue().equals("0"));
 478         assertTrue(leaf1.getType().getEnums().get(1).getStatus().isDeprecated());
 479         assertTrue(leaf1.getType().getEnums().get(2).getStatementIdentifier().equals("two"));
 480
 481         // - - - - status - - - - -
 482
 483         final YContainer cont2 = getContainer(module, "cont2");
 484
 485         assertNoFindingsOnStatement(getLeaf(cont2, "leaf11").getStatus());
 486         assertTrue(getLeaf(cont2, "leaf11").getStatus().isCurrent());
 487         assertNoFindingsOnStatement(getLeaf(cont2, "leaf12").getStatus());
 488         assertTrue(getLeaf(cont2, "leaf12").getStatus().isDeprecated());
 489         assertNoFindingsOnStatement(getLeaf(cont2, "leaf13").getStatus());
 490         assertTrue(getLeaf(cont2, "leaf13").getStatus().isObsolete());
 491
 492         assertStatementHasFindingOfType(getLeaf(cont2, "leaf14").getStatus(),
 493                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 494         assertFalse(getLeaf(cont2, "leaf14").getStatus().isCurrent());
 495         assertFalse(getLeaf(cont2, "leaf14").getStatus().isDeprecated());
 496         assertFalse(getLeaf(cont2, "leaf14").getStatus().isObsolete());
 497
 498         assertStatementHasFindingOfType(getLeaf(cont2, "leaf15").getStatus(),
 499                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 500         assertFalse(getLeaf(cont2, "leaf15").getStatus().isCurrent());
 501         assertFalse(getLeaf(cont2, "leaf15").getStatus().isDeprecated());
 502         assertFalse(getLeaf(cont2, "leaf15").getStatus().isObsolete());
 503
 504         // - - - - - container - - - - -
 505
 506         final YContainer cont3 = getContainer(module, "cont3");
 507         assertSubTreeNoFindings(cont3);
 508
 509         assertTrue(cont3.definesDataNode());
 510         assertTrue(cont3.definesSchemaNode());
 511
 512         assertTrue(cont3.getGroupings().size() == 1);
 513         assertTrue(cont3.getTypedefs().size() == 1);
 514         assertTrue(cont3.getLeafs().size() == 2);
 515         assertTrue(cont3.getChoices().size() == 1);
 516         assertTrue(cont3.getLists().size() == 1);
 517         assertTrue(cont3.getNotifications().size() == 1);
 518         assertTrue(cont3.getLeafLists().size() == 1);
 519         assertTrue(cont3.getAnydata().size() == 2);
 520         assertTrue(cont3.getAnyxmls().size() == 3);
 521
 522         // - - - - - choice and case - - - - -
 523
 524         final YChoice choice1 = getChoice(module, "choice1");
 525         assertSubTreeNoFindings(choice1);
 526
 527         assertTrue(choice1.getCases().size() == 8);
 528         assertTrue(choice1.getChoices().size() == 0);
 529         assertTrue(choice1.getConfig().getValue().equals("true"));
 530         assertTrue(choice1.getDefault().getValue().equals("case2"));
 531         assertTrue(choice1.getIfFeatures().size() == 0);
 532         assertTrue(choice1.getMandatory() == null);
 533         assertTrue(choice1.getStatus().isDeprecated());
 534         assertTrue(choice1.getWhens().size() == 1);
 535
 536         // will always return empty lists as shorthand notation is resolved.
 537         assertTrue(choice1.getAnydata().size() == 0);
 538         assertTrue(choice1.getAnyxmls().size() == 0);
 539         assertTrue(choice1.getContainers().size() == 0);
 540         assertTrue(choice1.getLists().size() == 0);
 541         assertTrue(choice1.getLeafs().size() == 0);
 542         assertTrue(choice1.getLeafLists().size() == 0);
 543
 544         final YCase case2 = getCase(choice1, "case2");
 545
 546         assertTrue(case2.getAnydata().size() == 1);
 547         assertTrue(case2.getAnyxmls().size() == 2);
 548         assertTrue(case2.getChoices().size() == 0);
 549         assertTrue(case2.getContainers().size() == 0);
 550         assertTrue(case2.getLeafs().size() == 1);
 551         assertTrue(case2.getLeafLists().size() == 1);
 552         assertTrue(case2.getLists().size() == 0);
 553         assertTrue(case2.getStatus().isObsolete());
 554         assertTrue(case2.getUses().size() == 0);
 555         assertTrue(case2.getWhens().size() == 1);
 556
 557         // - - - - - list - - - - -
 558
 559         final YList list4 = getList(module, "list4");
 560         assertSubTreeNoFindings(list4);
 561
 562         assertTrue(list4.definesDataNode());
 563         assertTrue(list4.definesSchemaNode());
 564         assertTrue(list4.getConfig().getValue().equals("true"));
 565         assertTrue(list4.getOrderedBy().isOrderedBySystem());
 566         assertTrue(list4.getStatus().isCurrent());
 567
 568         assertTrue(list4.getUses().size() == 0);
 569         assertTrue(list4.getContainers().size() == 0);
 570         assertTrue(list4.getIfFeatures().size() == 0);
 571         assertTrue(list4.getGroupings().size() == 1);
 572         assertTrue(list4.getTypedefs().size() == 1);
 573         assertTrue(list4.getActions().size() == 3);
 574         assertTrue(list4.getLeafs().size() == 2);
 575         assertTrue(list4.getChoices().size() == 1);
 576         assertTrue(list4.getLists().size() == 1);
 577         assertTrue(list4.getNotifications().size() == 1);
 578         assertTrue(list4.getLeafLists().size() == 1);
 579         assertTrue(list4.getAnydata().size() == 2);
 580         assertTrue(list4.getAnyxmls().size() == 3);
 581         assertTrue(list4.getMusts().size() == 0);
 582         assertTrue(list4.getWhens().size() == 0);
 583
 584         // - - - - - leaf-list - - - - -
 585
 586         final YContainer cont5 = getContainer(module, "cont5");
 587
 588         final YOrderedBy yOrderedBy = getLeafList(cont5, "leaflist51").getOrderedBy();
 589         assertEquals(StatementArgumentType.VALUE, yOrderedBy.getArgumentType());
 590         assertEquals(CY.STMT_ORDERED_BY, yOrderedBy.getStatementModuleAndName());
 591
 592         assertTrue(getLeafList(cont5, "leaflist51").getOrderedBy().isOrderedByUser());
 593         assertFalse(getLeafList(cont5, "leaflist51").getOrderedBy().isOrderedBySystem());
 594         assertSubTreeNoFindings(getLeafList(cont5, "leaflist51"));
 595
 596         assertFalse(getLeafList(cont5, "leaflist52").getOrderedBy().isOrderedByUser());
 597         assertTrue(getLeafList(cont5, "leaflist52").getOrderedBy().isOrderedBySystem());
 598         assertSubTreeNoFindings(getLeafList(cont5, "leaflist52"));
 599
 600         assertFalse(getLeafList(cont5, "leaflist53").getOrderedBy().isOrderedByUser());
 601         assertFalse(getLeafList(cont5, "leaflist53").getOrderedBy().isOrderedBySystem());
 602         assertStatementHasFindingOfType(getLeafList(cont5, "leaflist53").getOrderedBy(),
 603                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 604
 605         assertFalse(getLeafList(cont5, "leaflist54").getOrderedBy().isOrderedByUser());
 606         assertFalse(getLeafList(cont5, "leaflist54").getOrderedBy().isOrderedBySystem());
 607         assertStatementHasFindingOfType(getLeafList(cont5, "leaflist54").getOrderedBy(),
 608                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 609     }
 610
 611 }