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

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024 Ericsson
   4  *  Modifications Copyright (C) 2024-2025 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.data.test;
  22
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.io.File;
  26 import java.io.InputStream;
  27 import java.util.Arrays;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33 import java.util.stream.Collectors;
  34
  35 import org.junit.Test;
  36
  37 import org.oran.smo.yangtools.parser.data.YangData;
  38 import org.oran.smo.yangtools.parser.data.instance.ContainerInstance;
  39 import org.oran.smo.yangtools.parser.data.instance.DataTreeBuilderPredicate;
  40 import org.oran.smo.yangtools.parser.data.instance.LeafInstance;
  41 import org.oran.smo.yangtools.parser.data.instance.LeafListInstance;
  42 import org.oran.smo.yangtools.parser.data.instance.ListInstance;
  43 import org.oran.smo.yangtools.parser.data.instance.RootInstance;
  44 import org.oran.smo.yangtools.parser.findings.ParserFindingType;
  45 import org.oran.smo.yangtools.parser.input.YangInput;
  46 import org.oran.smo.yangtools.parser.input.YangInputResolver;
  47 import org.oran.smo.yangtools.parser.testutils.YangTestCommon;
  48
  49 public class ComplexInstanceDataTest extends YangTestCommon {
  50
  51     private static final String MODULE1 = "src/test/resources/data/instance-data/module1.yang";
  52     private static final String MODULE2 = "src/test/resources/data/instance-data/module2.yang";
  53
  54     private static final String DATA1_XML = "src/test/resources/data/instance-data/data1.xml";
  55     private static final String DATA2_XML = "src/test/resources/data/instance-data/data2.xml";
  56     private static final String DATA1_JSON = "src/test/resources/data/instance-data/data1.json";
  57     private static final String DATA2_JSON = "src/test/resources/data/instance-data/data2.json";
  58
  59     private static final String DATA3 = "src/test/resources/data/instance-data/data3.xml";
  60     private static final String DATA4 = "src/test/resources/data/instance-data/data4.xml";
  61
  62     private static final String DATA5 = "src/test/resources/data/instance-data/data5.xml";
  63     private static final String DATA6 = "src/test/resources/data/instance-data/data6.xml";
  64
  65     private static final String ERROR_DATA7 = "src/test/resources/data/instance-data/error-data7.xml";
  66     private static final String ERROR_DATA8 = "src/test/resources/data/instance-data/error-data8.xml";
  67     private static final String ERROR_DATA9 = "src/test/resources/data/instance-data/error-data9.xml";
  68     private static final String ERROR_DATA10 = "src/test/resources/data/instance-data/error-data10.json";
  69
  70     private static final String NS1 = "test:module1";
  71     private static final String NS2 = "test:module2";
  72
  73     @Test
  74     public void test_module1_data1_data2_xml() {
  75
  76         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
  77         parseAbsoluteYangData(Arrays.asList(DATA1_XML, DATA2_XML));
  78
  79         assertNoFindings();
  80
  81         final RootInstance combinedInstanceDataRoot = yangDeviceModel.getCombinedInstanceDataRoot();
  82
  83         // -------------- Simple stuff ----------------
  84
  85         final ContainerInstance cont1data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont1");
  86         assertTrue(cont1data != null);
  87         cont1data.getPath();
  88
  89         assertTrue(cont1data.getDataDomNode().getNamespace().equals("test:module1"));
  90         assertTrue(cont1data.getDataDomNode().getModuleName().equals("module1"));
  91
  92         final LeafInstance leaf11data = getLeafInstance(cont1data, NS1, "leaf11");
  93         assertTrue(leaf11data != null);
  94         assertTrue(leaf11data.getValue().equals("42"));
  95
  96         final LeafInstance leaf12data = getLeafInstance(cont1data, NS1, "leaf12");
  97         assertTrue(leaf12data != null);
  98         assertTrue(leaf12data.getValue().equals("58"));
  99
 100         final LeafInstance leaf13data = getLeafInstance(cont1data, NS1, "leaf13");
 101         assertTrue(leaf13data != null);
 102         assertTrue(leaf13data.getValue().equals("Hello!"));
 103
 104         final LeafInstance leaf14data = getLeafInstance(cont1data, NS1, "leaf14");
 105         assertTrue(leaf14data != null);
 106         assertTrue(leaf14data.getValue().equals(""));
 107
 108         // -------------- A few NPs and defaults ----------------
 109
 110         final ListInstance list2data4 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 111                 "4"));
 112         assertTrue(list2data4 != null);
 113
 114         LeafInstance leaf21data = getLeafInstance(list2data4, NS1, "leaf21");
 115         assertTrue(leaf21data != null);
 116         assertTrue(leaf21data.getValue().equals("4"));
 117
 118         ContainerInstance cont22data = getContainerInstance(list2data4, NS1, "cont22");
 119         assertTrue(cont22data != null);
 120
 121         LeafInstance leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 122         assertTrue(leaf23data != null);
 123         assertTrue(leaf23data.getValue().equals("One"));
 124
 125         LeafInstance leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 126         assertTrue(leaf24data != null);
 127         assertTrue(leaf24data.getValue().equals("Two"));
 128
 129         LeafInstance leaf25data = getLeafInstance(list2data4, NS1, "leaf25");
 130         assertTrue(leaf25data != null);
 131         assertTrue(leaf25data.getValue().equals("Three"));
 132
 133         List<LeafListInstance> leaflist26data = getLeafListInstances(list2data4, NS1, "leaflist26");
 134         assertTrue(leaflist26data != null);
 135         assertTrue(leaflist26data.size() == 1);
 136         assertTrue(leaflist26data.get(0).getValue().equals("Six"));
 137
 138         // ... ... ... ...
 139
 140         final ListInstance list2data5 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 141                 "5"));
 142         assertTrue(list2data5 != null);
 143
 144         leaf21data = getLeafInstance(list2data5, NS1, "leaf21");
 145         assertTrue(leaf21data != null);
 146         assertTrue(leaf21data.getValue().equals("5"));
 147
 148         cont22data = getContainerInstance(list2data5, NS1, "cont22");
 149         assertTrue(cont22data != null);
 150
 151         leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 152         assertTrue(leaf23data != null);
 153         assertTrue(leaf23data.getValue().equals("One"));
 154
 155         leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 156         assertTrue(leaf24data == null);
 157
 158         leaf25data = getLeafInstance(list2data5, NS1, "leaf25");
 159         assertTrue(leaf25data == null);
 160
 161         leaflist26data = getLeafListInstances(list2data5, NS1, "leaflist26");
 162         assertTrue(leaflist26data != null);
 163         assertTrue(leaflist26data.size() == 0);
 164
 165         // ... ... ... ...
 166
 167         final ListInstance list2data6 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 168                 "6"));
 169         assertTrue(list2data6 != null);
 170
 171         leaf21data = getLeafInstance(list2data6, NS1, "leaf21");
 172         assertTrue(leaf21data != null);
 173         assertTrue(leaf21data.getValue().equals("6"));
 174
 175         cont22data = getContainerInstance(list2data6, NS1, "cont22");
 176         assertTrue(cont22data == null);
 177
 178         leaf25data = getLeafInstance(list2data6, NS1, "leaf25");
 179         assertTrue(leaf25data == null);
 180
 181         leaflist26data = getLeafListInstances(list2data6, NS1, "leaflist26");
 182         assertTrue(leaflist26data != null);
 183         assertTrue(leaflist26data.size() == 0);
 184
 185         // --------------------- CDATA ---------------------------
 186
 187         final ContainerInstance cont8data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont8");
 188
 189         final LeafInstance leaf81data = getLeafInstance(cont8data, NS1, "leaf81");
 190         assertTrue(leaf81data != null);
 191         assertTrue(leaf81data.getValue().equals("should ignore whitespaces"));
 192
 193         final LeafInstance leaf82data = getLeafInstance(cont8data, NS1, "leaf82");
 194         assertTrue(leaf82data != null);
 195         assertTrue(leaf82data.getValue().equals("should also ignore whitespaces"));
 196
 197         final LeafInstance leaf83data = getLeafInstance(cont8data, NS1, "leaf83");
 198         assertTrue(leaf83data != null);
 199         assertTrue(leaf83data.getValue().equals("  should be 2 whitespaces either side  "));
 200
 201         final LeafInstance leaf84data = getLeafInstance(cont8data, NS1, "leaf84");
 202         assertTrue(leaf84data != null);
 203         assertTrue(leaf84data.getValue().equals("Before  should be 2 whitespaces either side  After"));
 204
 205         final LeafInstance leaf85data = getLeafInstance(cont8data, NS1, "leaf85");
 206         assertTrue(leaf85data != null);
 207         assertTrue(leaf85data.getValue().equals(""));
 208
 209         final LeafInstance leaf86data = getLeafInstance(cont8data, NS1, "leaf86");
 210         assertTrue(leaf86data != null);
 211         assertTrue(leaf86data.getValue().equals("blurb more blurb"));
 212     }
 213
 214     @Test
 215     public void test_module1_data1_data2_json() {
 216
 217         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 218         parseAbsoluteYangData(Arrays.asList(DATA1_JSON, DATA2_JSON));
 219
 220         assertNoFindings();
 221
 222         final RootInstance combinedInstanceDataRoot = yangDeviceModel.getCombinedInstanceDataRoot();
 223
 224         // -------------- Simple stuff ----------------
 225
 226         final ContainerInstance cont1data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont1");
 227         assertTrue(cont1data != null);
 228         cont1data.getPath();
 229
 230         assertTrue(cont1data.getDataDomNode().getNamespace().equals("test:module1"));
 231         assertTrue(cont1data.getDataDomNode().getModuleName().equals("module1"));
 232
 233         final LeafInstance leaf11data = getLeafInstance(cont1data, NS1, "leaf11");
 234         assertTrue(leaf11data != null);
 235         assertTrue(leaf11data.getValue().equals(new Long(42)));
 236
 237         final LeafInstance leaf12data = getLeafInstance(cont1data, NS1, "leaf12");
 238         assertTrue(leaf12data != null);
 239         assertTrue(leaf12data.getDataDomNode().getNamespace().equals("test:module1"));
 240         assertTrue(leaf12data.getDataDomNode().getModuleName().equals("module1"));
 241         assertTrue(leaf12data.getValue().equals(new Long(58)));
 242
 243         final LeafInstance leaf13data = getLeafInstance(cont1data, NS1, "leaf13");
 244         assertTrue(leaf13data != null);
 245         assertTrue(leaf13data.getValue().equals("Hello!"));
 246
 247         final LeafInstance leaf14data = getLeafInstance(cont1data, NS1, "leaf14");
 248         assertTrue(leaf14data != null);
 249         assertTrue(leaf14data.getValue().equals(""));
 250
 251         // -------------- A few NPs and defaults ----------------
 252
 253         final ListInstance list2data4 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 254                 "4"));
 255         assertTrue(list2data4 != null);
 256
 257         LeafInstance leaf21data = getLeafInstance(list2data4, NS1, "leaf21");
 258         assertTrue(leaf21data != null);
 259         assertTrue(leaf21data.getDataDomNode().getNamespace().equals("test:module1"));
 260         assertTrue(leaf21data.getDataDomNode().getModuleName().equals("module1"));
 261         assertTrue(leaf21data.getValue().equals(new Long(4)));
 262
 263         ContainerInstance cont22data = getContainerInstance(list2data4, NS1, "cont22");
 264         assertTrue(cont22data != null);
 265
 266         LeafInstance leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 267         assertTrue(leaf23data != null);
 268         assertTrue(leaf23data.getValue().equals("One"));
 269
 270         LeafInstance leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 271         assertTrue(leaf24data != null);
 272         assertTrue(leaf24data.getValue().equals("Two"));
 273
 274         LeafInstance leaf25data = getLeafInstance(list2data4, NS1, "leaf25");
 275         assertTrue(leaf25data != null);
 276         assertTrue(leaf25data.getValue().equals("Three"));
 277
 278         List<LeafListInstance> leaflist26data = getLeafListInstances(list2data4, NS1, "leaflist26");
 279         assertTrue(leaflist26data != null);
 280         assertTrue(leaflist26data.size() == 1);
 281         assertTrue(leaflist26data.get(0).getValue().equals("Six"));
 282
 283         // ... ... ... ...
 284
 285         final ListInstance list2data5 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 286                 "5"));
 287         assertTrue(list2data5 != null);
 288
 289         leaf21data = getLeafInstance(list2data5, NS1, "leaf21");
 290         assertTrue(leaf21data != null);
 291         assertTrue(leaf21data.getValue().equals(new Long(5)));
 292
 293         cont22data = getContainerInstance(list2data5, NS1, "cont22");
 294         assertTrue(cont22data != null);
 295
 296         leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 297         assertTrue(leaf23data != null);
 298         assertTrue(leaf23data.getValue().equals("One"));
 299
 300         leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 301         assertTrue(leaf24data == null);
 302
 303         leaf25data = getLeafInstance(list2data5, NS1, "leaf25");
 304         assertTrue(leaf25data == null);
 305
 306         leaflist26data = getLeafListInstances(list2data5, NS1, "leaflist26");
 307         assertTrue(leaflist26data != null);
 308         assertTrue(leaflist26data.size() == 0);
 309
 310         // ... ... ... ...
 311
 312         final ListInstance list2data6 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 313                 "6"));
 314         assertTrue(list2data6 != null);
 315
 316         leaf21data = getLeafInstance(list2data6, NS1, "leaf21");
 317         assertTrue(leaf21data != null);
 318         assertTrue(leaf21data.getValue().equals(new Long(6)));
 319
 320         cont22data = getContainerInstance(list2data6, NS1, "cont22");
 321         assertTrue(cont22data == null);
 322
 323         leaf25data = getLeafInstance(list2data6, NS1, "leaf25");
 324         assertTrue(leaf25data == null);
 325
 326         leaflist26data = getLeafListInstances(list2data6, NS1, "leaflist26");
 327         assertTrue(leaflist26data != null);
 328         assertTrue(leaflist26data.size() == 0);
 329
 330         // --------------------- Unions ---------------------------
 331
 332         final ContainerInstance cont5data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont5");
 333
 334         final LeafInstance leaf51data = getLeafInstance(cont5data, NS1, "leaf51");
 335         assertTrue(leaf51data != null);
 336         assertTrue(leaf51data.getValue().equals(""));
 337
 338         // --------------------- CDATA ---------------------------
 339
 340         final ContainerInstance cont8data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont8");
 341
 342         final LeafInstance leaf81data = getLeafInstance(cont8data, NS1, "leaf81");
 343         assertTrue(leaf81data != null);
 344         assertTrue(leaf81data.getValue().equals("should ignore whitespaces"));
 345
 346         final LeafInstance leaf82data = getLeafInstance(cont8data, NS1, "leaf82");
 347         assertTrue(leaf82data != null);
 348         assertTrue(leaf82data.getValue().equals("should also ignore whitespaces"));
 349
 350         final LeafInstance leaf83data = getLeafInstance(cont8data, NS1, "leaf83");
 351         assertTrue(leaf83data != null);
 352         assertTrue(leaf83data.getValue().equals("  should be 2 whitespaces either side  "));
 353     }
 354
 355     @Test
 356     public void test_module1_module2_data3_data4() {
 357
 358         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1, MODULE2));
 359         parseAbsoluteYangData(Arrays.asList(DATA3, DATA4));
 360
 361         assertNoFindings();
 362
 363         final RootInstance combinedInstanceDataRoot = yangDeviceModel.getCombinedInstanceDataRoot();
 364
 365         // -------------- A few NPs and defaults ----------------
 366
 367         final ListInstance list2data35 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 368                 "leaf21", "35"));
 369         assertTrue(list2data35 != null);
 370
 371         LeafInstance leaf21data = getLeafInstance(list2data35, NS1, "leaf21");
 372         assertTrue(leaf21data != null);
 373         assertTrue(leaf21data.getValue().equals("35"));
 374
 375         ContainerInstance cont22data = getContainerInstance(list2data35, NS1, "cont22");
 376         assertTrue(cont22data != null);
 377
 378         LeafInstance leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 379         assertTrue(leaf23data != null);
 380         assertTrue(leaf23data.getValue().equals("hello"));
 381
 382         LeafInstance leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 383         assertTrue(leaf24data != null);
 384         assertTrue(leaf24data.getValue().equals("world"));
 385
 386         LeafInstance leaf25data = getLeafInstance(list2data35, NS1, "leaf25");
 387         assertTrue(leaf25data != null);
 388         assertTrue(leaf25data.getValue().equals("sure"));
 389
 390         List<LeafListInstance> leaflist26data = getLeafListInstances(list2data35, NS1, "leaflist26");
 391         assertTrue(leaflist26data != null);
 392         assertTrue(leaflist26data.size() == 2);
 393         assertTrue(leaflist26data.get(0).getValue().equals("four"));
 394         assertTrue(leaflist26data.get(1).getValue().equals("five"));
 395
 396         // ... ... ... ...
 397
 398         final ListInstance list2data48 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 399                 "leaf21", "48"));
 400         assertTrue(list2data48 != null);
 401
 402         leaf21data = getLeafInstance(list2data48, NS1, "leaf21");
 403         assertTrue(leaf21data != null);
 404         assertTrue(leaf21data.getValue().equals("48"));
 405
 406         cont22data = getContainerInstance(list2data48, NS1, "cont22");
 407         assertTrue(cont22data == null);
 408
 409         leaf25data = getLeafInstance(list2data48, NS1, "leaf25");
 410         assertTrue(leaf25data == null);
 411
 412         leaflist26data = getLeafListInstances(list2data48, NS1, "leaflist26");
 413         assertTrue(leaflist26data != null);
 414         assertTrue(leaflist26data.size() == 0);
 415
 416         // -------------- Some choice handling ----------------
 417
 418         final ContainerInstance cont3data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont3");
 419         assertTrue(cont3data != null);
 420
 421         final LeafInstance leaf33data = getLeafInstance(cont3data, NS1, "leaf33");
 422         assertTrue(leaf33data == null);
 423
 424         final LeafInstance leaf34data = getLeafInstance(cont3data, NS1, "leaf34");
 425         assertTrue(leaf34data == null);
 426
 427         final ContainerInstance cont35data = getContainerInstance(cont3data, NS1, "cont35");
 428         assertTrue(cont35data == null);
 429
 430         final LeafInstance leaf38data = getLeafInstance(cont3data, NS1, "leaf38");
 431         assertTrue(leaf38data == null);
 432
 433         final ContainerInstance cont39data = getContainerInstance(cont3data, NS1, "cont39");
 434         assertTrue(cont39data != null);
 435
 436         // -------------- for augmentation ----------------
 437
 438         final ContainerInstance cont7data = getContainerInstance(combinedInstanceDataRoot, NS1, "cont7");
 439         assertTrue(cont7data != null);
 440
 441         final LeafInstance leaf71data = getLeafInstance(cont7data, NS2, "leaf71");
 442         assertTrue(leaf71data == null);
 443
 444         final LeafInstance leaf72data = getLeafInstance(cont7data, NS2, "leaf72");
 445         assertTrue(leaf72data != null);
 446         assertTrue(leaf72data.getValue().equals("-90"));
 447
 448         assertTrue(leaf72data.getDataDomNode().getNamespace().equals("test:module2"));
 449         assertTrue(leaf72data.getDataDomNode().getModuleName().equals("module2"));
 450     }
 451
 452     @Test
 453     public void test_module1_data5_data6() {
 454
 455         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 456         parseAbsoluteYangData(Arrays.asList(DATA5, DATA6));
 457
 458         assertNoFindings();
 459
 460         final RootInstance combinedInstanceDataRoot = yangDeviceModel.getCombinedInstanceDataRoot();
 461
 462         // -------------- first list instance ----------------
 463
 464         final ListInstance list2data501 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 465                 "leaf21", "501"));
 466         assertTrue(list2data501 != null);
 467
 468         LeafInstance leaf21data = getLeafInstance(list2data501, NS1, "leaf21");
 469         assertTrue(leaf21data != null);
 470         assertTrue(leaf21data.getValue().equals("501"));
 471
 472         ContainerInstance cont22data = getContainerInstance(list2data501, NS1, "cont22");
 473         assertTrue(cont22data != null);
 474
 475         LeafInstance leaf23data = getLeafInstance(cont22data, NS1, "leaf23");
 476         assertTrue(leaf23data != null);
 477         assertTrue(leaf23data.getValue().equals("hello"));
 478
 479         LeafInstance leaf24data = getLeafInstance(cont22data, NS1, "leaf24");
 480         assertTrue(leaf24data != null);
 481         assertTrue(leaf24data.getValue().equals("hi"));
 482
 483         LeafInstance leaf25data = getLeafInstance(list2data501, NS1, "leaf25");
 484         assertTrue(leaf25data != null);
 485         assertTrue(leaf25data.getValue().equals("world"));
 486
 487         List<Object> leaflist26data = getLeafListValues(list2data501, NS1, "leaflist26");
 488         assertTrue(leaflist26data != null);
 489         assertTrue(leaflist26data.size() == 0);
 490
 491         // -------------- second list instance ----------------
 492
 493         final ListInstance list2data502 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 494                 "leaf21", "502"));
 495         assertTrue(list2data501 != null);
 496
 497         leaf21data = getLeafInstance(list2data502, NS1, "leaf21");
 498         assertTrue(leaf21data != null);
 499         assertTrue(leaf21data.getValue().equals("502"));
 500
 501         cont22data = getContainerInstance(list2data502, NS1, "cont22");
 502         assertTrue(cont22data == null);
 503
 504         leaf25data = getLeafInstance(list2data502, NS1, "leaf25");
 505         assertTrue(leaf25data == null);
 506
 507         leaflist26data = getLeafListValues(list2data502, NS1, "leaflist26");
 508         assertTrue(leaflist26data != null);
 509         assertTrue(leaflist26data.size() == 4);
 510         assertTrue(leaflist26data.contains("red"));
 511         assertTrue(leaflist26data.contains("yellow"));
 512         assertTrue(leaflist26data.contains("green"));
 513         assertTrue(leaflist26data.contains("blue"));
 514     }
 515
 516     @Test
 517     public void test_module1_data5_data6_datainput() {
 518
 519         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 520         parseAbsoluteYangData(Arrays.asList(DATA5, DATA6));
 521
 522         assertNoFindings();
 523
 524         final YangData yangDataInput1 = yangDeviceModel.getYangInstanceDataInputs().get(0);
 525         assertTrue(yangDataInput1.getFindings().isEmpty());
 526         yangDataInput1.toString();
 527
 528         final YangData yangDataInput2 = yangDeviceModel.getYangInstanceDataInputs().get(1);
 529         assertTrue(yangDataInput2.getFindings().isEmpty());
 530     }
 531
 532     @Test
 533     public void test_module1_errordata7() {
 534
 535         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 536         parseAbsoluteYangData(Arrays.asList(ERROR_DATA7));
 537
 538         assertHasFindingOfType(ParserFindingType.P072_MISSING_KEY_VALUE.toString());
 539         assertHasFindingOfType(ParserFindingType.P075_CORRESPONDING_SCHEMA_NODE_NOT_FOUND.toString());
 540         assertHasFindingOfType(ParserFindingType.P076_DUPLICATE_INSTANCE_DATA.toString());
 541     }
 542
 543     @Test
 544     public void test_module1_errordata7_datainput() {
 545
 546         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 547         parseAbsoluteYangData(Arrays.asList(ERROR_DATA7));
 548
 549         final YangData yangDataInput = yangDeviceModel.getYangInstanceDataInputs().get(0);
 550         final Set<String> findingTypes = yangDataInput.getFindings().stream().map(finding -> finding.getFindingType())
 551                 .collect(Collectors.toSet());
 552
 553         assertTrue(findingTypes.contains(ParserFindingType.P072_MISSING_KEY_VALUE.toString()));
 554         assertTrue(findingTypes.contains(ParserFindingType.P075_CORRESPONDING_SCHEMA_NODE_NOT_FOUND.toString()));
 555         assertTrue(findingTypes.contains(ParserFindingType.P076_DUPLICATE_INSTANCE_DATA.toString()));
 556     }
 557
 558     @Test
 559     public void test_module1_provoke_exception() {
 560
 561         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 562
 563         final YangInput yangInput = new YangInput() {
 564             @Override
 565             public String getName() {
 566                 return null;
 567             }
 568
 569             @Override
 570             public File getFile() {
 571                 return null;
 572             }
 573
 574             @Override
 575             public InputStream getInputStream() {
 576                 return null;
 577             }
 578
 579             @Override
 580             public String getMediaType() {
 581                 return null;
 582             }
 583         };
 584
 585         final YangInputResolver yangInputResolver = new YangInputResolver() {
 586             @Override
 587             public Set<YangInput> getResolvedYangInput() {
 588                 return Collections.singleton(yangInput);
 589             }
 590         };
 591
 592         yangDeviceModel.parseYangData(context, yangInputResolver, new DataTreeBuilderPredicate());
 593
 594         assertHasFindingOfType(ParserFindingType.P000_UNSPECIFIED_ERROR.toString());
 595     }
 596
 597     @Test
 598     public void test_module1_errordata8_errordata9() {
 599
 600         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 601         parseAbsoluteYangData(Arrays.asList(ERROR_DATA8, ERROR_DATA9));
 602
 603         assertHasFindingOfType(ParserFindingType.P073_LEAF_VALUE_ALREADY_SET.toString());
 604         assertHasFindingOfType(ParserFindingType.P080_NULL_VALUE.toString());
 605
 606         final RootInstance combinedInstanceDataRoot = yangDeviceModel.getCombinedInstanceDataRoot();
 607
 608         final ListInstance list2data1 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 609                 "1"));
 610         assertTrue(list2data1 != null);
 611
 612         LeafInstance leaf25data = getLeafInstance(list2data1, NS1, "leaf25");
 613         assertTrue(leaf25data == null);
 614
 615         final ListInstance list2data2 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 616                 "2"));
 617         assertTrue(list2data2 != null);
 618
 619         leaf25data = getLeafInstance(list2data2, NS1, "leaf25");
 620         assertTrue(leaf25data != null);
 621         assertTrue(leaf25data.getValue().equals("abc 123"));
 622
 623         final ListInstance list2data3 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 624                 "3"));
 625         assertTrue(list2data3 != null);
 626
 627         leaf25data = getLeafInstance(list2data3, NS1, "leaf25");
 628         assertTrue(leaf25data != null);
 629         assertTrue(leaf25data.getValue().equals("abc 456"));
 630
 631         final ListInstance list2data4 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 632                 "4"));
 633         assertTrue(list2data4 != null);
 634
 635         leaf25data = getLeafInstance(list2data4, NS1, "leaf25");
 636         assertTrue(leaf25data != null);
 637         assertTrue(leaf25data.getValue().equals("abc 123"));
 638
 639         final ListInstance list2data5 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue("leaf21",
 640                 "5"));
 641         assertTrue(list2data5 != null);
 642
 643         leaf25data = getLeafInstance(list2data5, NS1, "leaf25");
 644         assertTrue(leaf25data != null);
 645         assertTrue(leaf25data.getValue().equals("abc 123"));
 646
 647         // ===================================
 648
 649         final ListInstance list2data51 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 650                 "leaf21", "51"));
 651         assertTrue(list2data51 != null);
 652
 653         List<LeafListInstance> leaflist26data = getLeafListInstances(list2data51, NS1, "leaflist26");
 654         assertTrue(leaflist26data != null);
 655         assertTrue(leaflist26data.size() == 2);
 656         assertTrue(leaflist26data.get(0).getValue().equals("abc"));
 657         assertTrue(leaflist26data.get(1).getValue().equals("def"));
 658
 659         final ListInstance list2data52 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 660                 "leaf21", "52"));
 661         assertTrue(list2data52 != null);
 662
 663         leaflist26data = getLeafListInstances(list2data52, NS1, "leaflist26");
 664         assertTrue(leaflist26data != null);
 665         assertTrue(leaflist26data.size() == 2);
 666         assertTrue(leaflist26data.get(0).getValue().equals("abc"));
 667         assertTrue(leaflist26data.get(1).getValue().equals("def"));
 668
 669         final ListInstance list2data53 = getListInstanceData(combinedInstanceDataRoot, NS1, "list2", createKeyValue(
 670                 "leaf21", "53"));
 671         assertTrue(list2data53 != null);
 672
 673         leaflist26data = getLeafListInstances(list2data53, NS1, "leaflist26");
 674         assertTrue(leaflist26data != null);
 675         assertTrue(leaflist26data.size() == 2);
 676         assertTrue(leaflist26data.get(0).getValue().equals("abc"));
 677         assertTrue(leaflist26data.get(1).getValue().equals("def"));
 678     }
 679
 680     @Test
 681     public void test_module1_errordata10_json() {
 682
 683         parseAbsoluteImplementsYangModels(Arrays.asList(MODULE1));
 684         parseAbsoluteYangData(Arrays.asList(ERROR_DATA10));
 685
 686         assertHasFindingOfType(ParserFindingType.P080_NULL_VALUE.toString());
 687     }
 688
 689     private static Map<String, String> createKeyValue(final String key, final String value) {
 690         final Map<String, String> map = new HashMap<>();
 691         map.put(key, value);
 692         return map;
 693     }
 694
 695 }