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.util.test;
  22
  23 import static org.junit.Assert.assertTrue;
  24 import static org.junit.Assert.fail;
  25
  26 import java.io.File;
  27 import java.util.ArrayList;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.junit.Before;
  33 import org.junit.Test;
  34
  35 import org.oran.smo.yangtools.parser.ParserExecutionContext;
  36 import org.oran.smo.yangtools.parser.YangDeviceModel;
  37 import org.oran.smo.yangtools.parser.findings.FindingsManager;
  38 import org.oran.smo.yangtools.parser.findings.ModifyableFindingSeverityCalculator;
  39 import org.oran.smo.yangtools.parser.findings.ParserFindingType;
  40 import org.oran.smo.yangtools.parser.input.FileBasedYangInput;
  41 import org.oran.smo.yangtools.parser.model.ConformanceType;
  42 import org.oran.smo.yangtools.parser.model.YangModel;
  43 import org.oran.smo.yangtools.parser.model.statements.yang.YLeaf;
  44 import org.oran.smo.yangtools.parser.model.statements.yang.YModule;
  45 import org.oran.smo.yangtools.parser.model.statements.yang.YType;
  46 import org.oran.smo.yangtools.parser.model.util.DataTypeHelper;
  47 import org.oran.smo.yangtools.parser.model.util.DataTypeHelper.YangDataType;
  48 import org.oran.smo.yangtools.parser.testutils.YangTestCommon;
  49
  50 public class DataTypeHelperTest {
  51
  52     private YangDeviceModel yangDeviceModel;
  53     private ModifyableFindingSeverityCalculator severityCalculator;
  54     private FindingsManager findingsManager;
  55     private ParserExecutionContext context;
  56
  57     @Before
  58     public void setUp() {
  59         yangDeviceModel = new YangDeviceModel("Yang Parser JAR Test Device Model");
  60         severityCalculator = new ModifyableFindingSeverityCalculator();
  61         findingsManager = new FindingsManager(severityCalculator);
  62         context = new ParserExecutionContext(findingsManager);
  63     }
  64
  65     @Test
  66     public void test_is_yang_integer_type() {
  67
  68         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.UINT8) == true);
  69         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.UINT16) == true);
  70         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.UINT32) == true);
  71         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.UINT64) == true);
  72
  73         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.INT8) == true);
  74         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.INT16) == true);
  75         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.INT32) == true);
  76         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.INT64) == true);
  77
  78         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.DECIMAL64) == false);
  79         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.STRING) == false);
  80         assertTrue(DataTypeHelper.isYangIntegerType(YangDataType.BOOLEAN) == false);
  81     }
  82
  83     @Test
  84     public void test_get_yang_data_type() {
  85
  86         assertTrue(DataTypeHelper.getYangDataType("uint8") == YangDataType.UINT8);
  87         assertTrue(DataTypeHelper.getYangDataType("UINT8") == YangDataType.UINT8);
  88         assertTrue(DataTypeHelper.getYangDataType("uInt8") == YangDataType.UINT8);
  89
  90         assertTrue(DataTypeHelper.getYangDataType("uint16") == YangDataType.UINT16);
  91         assertTrue(DataTypeHelper.getYangDataType("uint32") == YangDataType.UINT32);
  92         assertTrue(DataTypeHelper.getYangDataType("uint64") == YangDataType.UINT64);
  93
  94         assertTrue(DataTypeHelper.getYangDataType("int8") == YangDataType.INT8);
  95         assertTrue(DataTypeHelper.getYangDataType("int16") == YangDataType.INT16);
  96         assertTrue(DataTypeHelper.getYangDataType("int32") == YangDataType.INT32);
  97         assertTrue(DataTypeHelper.getYangDataType("int64") == YangDataType.INT64);
  98
  99         assertTrue(DataTypeHelper.getYangDataType("decimal64") == YangDataType.DECIMAL64);
 100         assertTrue(DataTypeHelper.getYangDataType("string") == YangDataType.STRING);
 101         assertTrue(DataTypeHelper.getYangDataType("boolean") == YangDataType.BOOLEAN);
 102         assertTrue(DataTypeHelper.getYangDataType("enumeration") == YangDataType.ENUMERATION);
 103         assertTrue(DataTypeHelper.getYangDataType("bits") == YangDataType.BITS);
 104         assertTrue(DataTypeHelper.getYangDataType("binary") == YangDataType.BINARY);
 105         assertTrue(DataTypeHelper.getYangDataType("leafref") == YangDataType.LEAFREF);
 106         assertTrue(DataTypeHelper.getYangDataType("identityref") == YangDataType.IDENTITYREF);
 107         assertTrue(DataTypeHelper.getYangDataType("empty") == YangDataType.EMPTY);
 108         assertTrue(DataTypeHelper.getYangDataType("union") == YangDataType.UNION);
 109         assertTrue(DataTypeHelper.getYangDataType("instance-identifier") == YangDataType.INSTANCE_IDENTIFIER);
 110
 111         assertTrue(DataTypeHelper.getYangDataType("") == YangDataType.DERIVED____TYPE);
 112         assertTrue(DataTypeHelper.getYangDataType("prefix:someType") == YangDataType.DERIVED____TYPE);
 113
 114         assertTrue(DataTypeHelper.isBuiltInType("decimal64") == true);
 115         assertTrue(DataTypeHelper.isBuiltInType("prefix:someType") == false);
 116     }
 117
 118     @Test
 119     public void test_calculate_position_of_bits() {
 120
 121         severityCalculator.suppressFinding(ParserFindingType.P143_ENUM_WITHOUT_VALUE.toString());
 122         severityCalculator.suppressFinding(ParserFindingType.P144_BIT_WITHOUT_POSITION.toString());
 123
 124         final List<YangModel> yangFiles = new ArrayList<>();
 125         yangFiles.add(new YangModel(new FileBasedYangInput(new File("src/test/resources/model-util/module1.yang")),
 126                 ConformanceType.IMPLEMENT));
 127         yangDeviceModel.parseIntoYangModels(context, yangFiles);
 128
 129         final YModule module1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot()
 130                 .getModule();
 131
 132         final YLeaf leaf1 = module1.getLeafs().get(0);
 133         final YLeaf leaf2 = module1.getLeafs().get(1);
 134
 135         Map<String, Long> positionOfBitsLeaf1 = DataTypeHelper.calculatePositionOfBits(null, leaf1.getType(), null);
 136
 137         assertTrue(positionOfBitsLeaf1.size() == 3);
 138         assertTrue(positionOfBitsLeaf1.containsKey("one"));
 139         assertTrue(positionOfBitsLeaf1.containsKey("two"));
 140         assertTrue(positionOfBitsLeaf1.containsKey("three"));
 141         assertTrue(positionOfBitsLeaf1.get("one") == 0);
 142         assertTrue(positionOfBitsLeaf1.get("two") == 1);
 143         assertTrue(positionOfBitsLeaf1.get("three") == 2);
 144
 145         Map<String, Long> positionOfBitsLeaf2 = DataTypeHelper.calculatePositionOfBits(null, leaf2.getType(), null);
 146
 147         assertTrue(positionOfBitsLeaf2.size() == 3);
 148         assertTrue(positionOfBitsLeaf2.containsKey("one"));
 149         assertTrue(positionOfBitsLeaf2.containsKey("two"));
 150         assertTrue(positionOfBitsLeaf2.containsKey("three"));
 151         assertTrue(positionOfBitsLeaf2.get("one") == 71);
 152         assertTrue(positionOfBitsLeaf2.get("two") == 72);
 153         assertTrue(positionOfBitsLeaf2.get("three") == 402);
 154
 155         final Map<String, Long> predefinedMapping = new HashMap<>();
 156         predefinedMapping.put("zero", 999L);
 157         predefinedMapping.put("one", 36L);
 158
 159         positionOfBitsLeaf1 = DataTypeHelper.calculatePositionOfBits(null, leaf1.getType(), predefinedMapping);
 160
 161         assertTrue(positionOfBitsLeaf1.get("one") == 36);
 162         assertTrue(positionOfBitsLeaf1.get("two") == 37);
 163         assertTrue(positionOfBitsLeaf1.get("three") == 38);
 164
 165         predefinedMapping.put("two", 99999999999999999L);
 166         predefinedMapping.put("three", 36L);
 167
 168         positionOfBitsLeaf1 = DataTypeHelper.calculatePositionOfBits(null, leaf1.getType(), predefinedMapping);
 169
 170         assertTrue(positionOfBitsLeaf1.size() == 3);
 171         assertTrue(positionOfBitsLeaf1.get("one") == 36);
 172         assertTrue(positionOfBitsLeaf1.get("two") == 99999999999999999L);
 173         assertTrue(positionOfBitsLeaf1.get("three") == 36);
 174
 175         assertTrue(findingsManager.getAllFindings().isEmpty());
 176
 177         positionOfBitsLeaf1 = DataTypeHelper.calculatePositionOfBits(findingsManager, leaf1.getType(), predefinedMapping);
 178
 179         assertTrue(positionOfBitsLeaf1.size() == 3);
 180         assertTrue(positionOfBitsLeaf1.get("one") == 36);
 181         assertTrue(positionOfBitsLeaf1.get("two") == 99999999999999999L);
 182         assertTrue(positionOfBitsLeaf1.get("three") == 36);
 183
 184         assertTrue(findingsManager.hasFindingOfType(ParserFindingType.P053_INVALID_VALUE.toString()));
 185     }
 186
 187     @Test
 188     public void test_calculate_values_of_enums() {
 189
 190         severityCalculator.suppressFinding(ParserFindingType.P143_ENUM_WITHOUT_VALUE.toString());
 191         severityCalculator.suppressFinding(ParserFindingType.P144_BIT_WITHOUT_POSITION.toString());
 192
 193         final List<YangModel> yangFiles = new ArrayList<>();
 194         yangFiles.add(new YangModel(new FileBasedYangInput(new File("src/test/resources/model-util/module1.yang")),
 195                 ConformanceType.IMPLEMENT));
 196         yangDeviceModel.parseIntoYangModels(context, yangFiles);
 197
 198         final YModule module1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot()
 199                 .getModule();
 200
 201         final YLeaf leaf3 = module1.getLeafs().get(2);
 202         final YLeaf leaf4 = module1.getLeafs().get(3);
 203
 204         Map<String, Long> valuesOfEnumsLeaf3 = DataTypeHelper.calculateValuesOfEnums(null, leaf3.getType(), null);
 205
 206         assertTrue(valuesOfEnumsLeaf3.size() == 3);
 207         assertTrue(valuesOfEnumsLeaf3.containsKey("one"));
 208         assertTrue(valuesOfEnumsLeaf3.containsKey("two"));
 209         assertTrue(valuesOfEnumsLeaf3.containsKey("three"));
 210         assertTrue(valuesOfEnumsLeaf3.get("one") == 0);
 211         assertTrue(valuesOfEnumsLeaf3.get("two") == 1);
 212         assertTrue(valuesOfEnumsLeaf3.get("three") == 2);
 213
 214         Map<String, Long> valuesOfEnumsLeaf4 = DataTypeHelper.calculateValuesOfEnums(null, leaf4.getType(), null);
 215
 216         assertTrue(valuesOfEnumsLeaf4.size() == 3);
 217         assertTrue(valuesOfEnumsLeaf4.containsKey("one"));
 218         assertTrue(valuesOfEnumsLeaf4.containsKey("two"));
 219         assertTrue(valuesOfEnumsLeaf4.containsKey("three"));
 220         assertTrue(valuesOfEnumsLeaf4.get("one") == 71);
 221         assertTrue(valuesOfEnumsLeaf4.get("two") == 72);
 222         assertTrue(valuesOfEnumsLeaf4.get("three") == 402);
 223
 224         final Map<String, Long> predefinedMapping = new HashMap<>();
 225         predefinedMapping.put("zero", 999L);
 226         predefinedMapping.put("one", 36L);
 227
 228         valuesOfEnumsLeaf3 = DataTypeHelper.calculateValuesOfEnums(null, leaf3.getType(), predefinedMapping);
 229
 230         assertTrue(valuesOfEnumsLeaf3.get("one") == 36);
 231         assertTrue(valuesOfEnumsLeaf3.get("two") == 37);
 232         assertTrue(valuesOfEnumsLeaf3.get("three") == 38);
 233
 234         predefinedMapping.put("two", 99999999999999999L);
 235         predefinedMapping.put("three", 36L);
 236
 237         valuesOfEnumsLeaf3 = DataTypeHelper.calculateValuesOfEnums(null, leaf3.getType(), predefinedMapping);
 238
 239         assertTrue(valuesOfEnumsLeaf3.size() == 3);
 240         assertTrue(valuesOfEnumsLeaf3.get("one") == 36);
 241         assertTrue(valuesOfEnumsLeaf3.get("two") == 99999999999999999L);
 242         assertTrue(valuesOfEnumsLeaf3.get("three") == 36);
 243
 244         assertTrue(findingsManager.getAllFindings().isEmpty());
 245
 246         valuesOfEnumsLeaf3 = DataTypeHelper.calculateValuesOfEnums(findingsManager, leaf3.getType(), predefinedMapping);
 247
 248         assertTrue(valuesOfEnumsLeaf3.size() == 3);
 249         assertTrue(valuesOfEnumsLeaf3.get("one") == 36);
 250         assertTrue(valuesOfEnumsLeaf3.get("two") == 99999999999999999L);
 251         assertTrue(valuesOfEnumsLeaf3.get("three") == 36);
 252
 253         assertTrue(findingsManager.hasFindingOfType(ParserFindingType.P053_INVALID_VALUE.toString()));
 254     }
 255
 256     @Test
 257     public void test_stringefied_values() {
 258
 259         severityCalculator.suppressFinding(ParserFindingType.P143_ENUM_WITHOUT_VALUE.toString());
 260         severityCalculator.suppressFinding(ParserFindingType.P144_BIT_WITHOUT_POSITION.toString());
 261
 262         final List<YangModel> yangFiles = new ArrayList<>();
 263         yangFiles.add(new YangModel(new FileBasedYangInput(new File(
 264                 "src/test/resources/model-util/stringefied-values-test.yang")), ConformanceType.IMPLEMENT));
 265         yangDeviceModel.parseIntoYangModels(context, yangFiles);
 266
 267         assertTrue(findingsManager.getAllFindings().isEmpty());
 268
 269         final YModule module = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule();
 270
 271         // ------------------------- integers ------------------------------
 272
 273         final YType type11 = YangTestCommon.getLeaf(module, "leaf11").getType();
 274         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type11) == false);
 275         assertTrue(DataTypeHelper.isStringefiedValueValid("not a number", type11) == false);
 276         assertTrue(DataTypeHelper.isStringefiedValueValid("-123456", type11) == false);
 277         assertTrue(DataTypeHelper.isStringefiedValueValid("123456", type11) == false);
 278         assertTrue(DataTypeHelper.isStringefiedValueValid("0", type11) == true);
 279
 280         final YType type12 = YangTestCommon.getLeaf(module, "leaf12").getType();
 281         assertTrue(DataTypeHelper.isStringefiedValueValid("-123456", type12) == false);
 282         assertTrue(DataTypeHelper.isStringefiedValueValid("123456", type12) == false);
 283         assertTrue(DataTypeHelper.isStringefiedValueValid("9", type12) == false);
 284         assertTrue(DataTypeHelper.isStringefiedValueValid("21", type12) == false);
 285         assertTrue(DataTypeHelper.isStringefiedValueValid("10", type12) == true);
 286         assertTrue(DataTypeHelper.isStringefiedValueValid("20", type12) == true);
 287
 288         final YType type13 = YangTestCommon.getLeaf(module, "leaf13").getType();
 289         assertTrue(DataTypeHelper.isStringefiedValueValid("-123456", type13) == false);
 290         assertTrue(DataTypeHelper.isStringefiedValueValid("123456", type13) == false);
 291         assertTrue(DataTypeHelper.isStringefiedValueValid("-1", type13) == false);
 292         assertTrue(DataTypeHelper.isStringefiedValueValid("21", type13) == false);
 293         assertTrue(DataTypeHelper.isStringefiedValueValid("39", type13) == false);
 294         assertTrue(DataTypeHelper.isStringefiedValueValid("61", type13) == false);
 295         assertTrue(DataTypeHelper.isStringefiedValueValid("0", type13) == true);
 296         assertTrue(DataTypeHelper.isStringefiedValueValid("20", type13) == true);
 297         assertTrue(DataTypeHelper.isStringefiedValueValid("40", type13) == true);
 298         assertTrue(DataTypeHelper.isStringefiedValueValid("60", type13) == true);
 299
 300         // ------------------------- decimal64 ------------------------------
 301
 302         final YType type21 = YangTestCommon.getLeaf(module, "leaf21").getType();
 303         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type21) == false);
 304         assertTrue(DataTypeHelper.isStringefiedValueValid("not a number", type21) == false);
 305         assertTrue(DataTypeHelper.isStringefiedValueValid("1.11", type21) == false);
 306         assertTrue(DataTypeHelper.isStringefiedValueValid("-1.11", type21) == false);
 307         assertTrue(DataTypeHelper.isStringefiedValueValid("1", type21) == true);
 308         assertTrue(DataTypeHelper.isStringefiedValueValid("1.1", type21) == true);
 309
 310         final YType type22 = YangTestCommon.getLeaf(module, "leaf22").getType();
 311         assertTrue(DataTypeHelper.isStringefiedValueValid("5.000001", type22) == false);
 312         assertTrue(DataTypeHelper.isStringefiedValueValid("-0.001", type22) == false);
 313         assertTrue(DataTypeHelper.isStringefiedValueValid("10.001", type22) == false);
 314         assertTrue(DataTypeHelper.isStringefiedValueValid("0.000", type22) == true);
 315         assertTrue(DataTypeHelper.isStringefiedValueValid("10.000", type22) == true);
 316         assertTrue(DataTypeHelper.isStringefiedValueValid("20.199", type22) == false);
 317         assertTrue(DataTypeHelper.isStringefiedValueValid("20.200", type22) == true);
 318
 319         final YType type23 = YangTestCommon.getLeaf(module, "leaf23").getType();
 320         assertTrue(DataTypeHelper.isStringefiedValueValid("123.45", type23) == false);
 321         assertTrue(DataTypeHelper.isStringefiedValueValid("-123.45", type23) == false);
 322         assertTrue(DataTypeHelper.isStringefiedValueValid("1.2345", type23) == true);
 323         assertTrue(DataTypeHelper.isStringefiedValueValid("-1.2345", type23) == true);
 324
 325         // ------------------------- boolean ------------------------------
 326
 327         final YType type31 = YangTestCommon.getLeaf(module, "leaf31").getType();
 328         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type31) == false);
 329         assertTrue(DataTypeHelper.isStringefiedValueValid("not a boolean", type31) == false);
 330         assertTrue(DataTypeHelper.isStringefiedValueValid("", type31) == false);
 331         assertTrue(DataTypeHelper.isStringefiedValueValid("TRUE", type31) == false);
 332         assertTrue(DataTypeHelper.isStringefiedValueValid("true", type31) == true);
 333         assertTrue(DataTypeHelper.isStringefiedValueValid("false", type31) == true);
 334
 335         // ------------------------- enumeration ------------------------------
 336
 337         final YType type41 = YangTestCommon.getLeaf(module, "leaf41").getType();
 338         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type41) == false);
 339         assertTrue(DataTypeHelper.isStringefiedValueValid("", type41) == false);
 340         assertTrue(DataTypeHelper.isStringefiedValueValid("BLACK", type41) == false);
 341         assertTrue(DataTypeHelper.isStringefiedValueValid("         RED        ", type41) == false);
 342         assertTrue(DataTypeHelper.isStringefiedValueValid("red", type41) == false);
 343         assertTrue(DataTypeHelper.isStringefiedValueValid("RED", type41) == true);
 344
 345         // ------------------------- bits ------------------------------
 346
 347         final YType type51 = YangTestCommon.getLeaf(module, "leaf51").getType();
 348         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type51) == false);
 349         assertTrue(DataTypeHelper.isStringefiedValueValid("ZERO", type51) == false);
 350         assertTrue(DataTypeHelper.isStringefiedValueValid("one", type51) == false);
 351         assertTrue(DataTypeHelper.isStringefiedValueValid("", type51) == true);
 352         assertTrue(DataTypeHelper.isStringefiedValueValid("         ONE        ", type51) == true);
 353         assertTrue(DataTypeHelper.isStringefiedValueValid("ONE", type51) == true);
 354         assertTrue(DataTypeHelper.isStringefiedValueValid("ONE TWO", type51) == true);
 355         assertTrue(DataTypeHelper.isStringefiedValueValid("TWO ONE", type51) == true);
 356         assertTrue(DataTypeHelper.isStringefiedValueValid("THREE ONE", type51) == true);
 357         assertTrue(DataTypeHelper.isStringefiedValueValid("THREE one", type51) == false);
 358         assertTrue(DataTypeHelper.isStringefiedValueValid("ONE ONE", type51) == false);
 359
 360         // ------------------------- string ------------------------------
 361
 362         final YType type61 = YangTestCommon.getLeaf(module, "leaf61").getType();
 363         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type61) == false);
 364         assertTrue(DataTypeHelper.isStringefiedValueValid("", type61) == true);
 365         assertTrue(DataTypeHelper.isStringefiedValueValid("hello", type61) == true);
 366
 367         final YType type62 = YangTestCommon.getLeaf(module, "leaf62").getType();
 368         assertTrue(DataTypeHelper.isStringefiedValueValid("", type62) == false);
 369         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCD", type62) == false);
 370         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFGHIJK", type62) == false);
 371         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDE", type62) == true);
 372         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFGHIJ", type62) == true);
 373
 374         final YType type63 = YangTestCommon.getLeaf(module, "leaf63").getType();
 375         assertTrue(DataTypeHelper.isStringefiedValueValid("", type63) == false);
 376         assertTrue(DataTypeHelper.isStringefiedValueValid("A", type63) == false);
 377         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDE", type63) == false);
 378         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFG", type63) == false);
 379         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFGHIJK", type63) == false);
 380         assertTrue(DataTypeHelper.isStringefiedValueValid("AB", type63) == true);
 381         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCD", type63) == true);
 382         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFGH", type63) == true);
 383         assertTrue(DataTypeHelper.isStringefiedValueValid("ABCDEFGHIJ", type63) == true);
 384
 385         final YType type64 = YangTestCommon.getLeaf(module, "leaf64").getType();
 386         assertTrue(DataTypeHelper.isStringefiedValueValid("", type64) == false);
 387         assertTrue(DataTypeHelper.isStringefiedValueValid("a", type64) == false);
 388         assertTrue(DataTypeHelper.isStringefiedValueValid("c", type64) == false);
 389         assertTrue(DataTypeHelper.isStringefiedValueValid("ac", type64) == true);
 390         assertTrue(DataTypeHelper.isStringefiedValueValid("abc", type64) == true);
 391         assertTrue(DataTypeHelper.isStringefiedValueValid("abbc", type64) == true);
 392         assertTrue(DataTypeHelper.isStringefiedValueValid("abbc", type64) == true);
 393         assertTrue(DataTypeHelper.isStringefiedValueValid("aBc", type64) == false);
 394
 395         // ------------------------- empty ------------------------------
 396
 397         final YType type71 = YangTestCommon.getLeaf(module, "leaf71").getType();
 398         assertTrue(DataTypeHelper.isStringefiedValueValid(null, type71) == true);
 399         assertTrue(DataTypeHelper.isStringefiedValueValid("", type71) == true);
 400         assertTrue(DataTypeHelper.isStringefiedValueValid("hello", type71) == false);
 401
 402         // ------------------------- union ------------------------------
 403
 404         final YType type81 = YangTestCommon.getLeaf(module, "leaf81").getType();
 405
 406         try {
 407             DataTypeHelper.isStringefiedValueValid("blurb", type81);
 408             fail();
 409         } catch (final Exception expected) {
 410         }
 411     }
 412
 413 }