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.yangdom.test;
  22
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.util.Arrays;
  26
  27 import org.junit.Test;
  28
  29 import org.oran.smo.yangtools.parser.findings.ParserFindingType;
  30 import org.oran.smo.yangtools.parser.model.statements.yang.YContainer;
  31 import org.oran.smo.yangtools.parser.model.statements.yang.YInput;
  32 import org.oran.smo.yangtools.parser.model.statements.yang.YLeaf;
  33 import org.oran.smo.yangtools.parser.model.statements.yang.YModule;
  34 import org.oran.smo.yangtools.parser.model.statements.yang.YRpc;
  35 import org.oran.smo.yangtools.parser.model.statements.yang.YSubmodule;
  36 import org.oran.smo.yangtools.parser.model.yangdom.YangDomElement;
  37 import org.oran.smo.yangtools.parser.testutils.YangTestCommon;
  38
  39 public class BasicParsingTest extends YangTestCommon {
  40
  41     @Test
  42     public void test_empty_file() {
  43         parseAbsoluteImplementsYangModels(Arrays.asList(
  44                 "src/test/resources/model-yangdom/basic-parsing-test/empty-file.yang"));
  45         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
  46
  47         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
  48     }
  49
  50     @Test
  51     public void test_semicolon_only() {
  52         parseAbsoluteImplementsYangModels(Arrays.asList(
  53                 "src/test/resources/model-yangdom/basic-parsing-test/semicolon-only.yang"));
  54         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
  55
  56         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
  57     }
  58
  59     @Test
  60     public void test_hello_world() {
  61         parseAbsoluteImplementsYangModels(Arrays.asList(
  62                 "src/test/resources/model-yangdom/basic-parsing-test/hello-world.yang"));
  63         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
  64
  65         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
  66     }
  67
  68     @Test
  69     public void test_no_left_brace() {
  70         parseAbsoluteImplementsYangModels(Arrays.asList(
  71                 "src/test/resources/model-yangdom/basic-parsing-test/no-left-brace.yang"));
  72         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
  73
  74         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
  75     }
  76
  77     @Test
  78     public void test_junk_at_end() {
  79         parseAbsoluteImplementsYangModels(Arrays.asList(
  80                 "src/test/resources/model-yangdom/basic-parsing-test/junk-at-end.yang"));
  81         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
  82
  83         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
  84         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("junk-at-end-module").size() == 1);
  85     }
  86
  87     @Test
  88     public void test_block_comments() {
  89         parseAbsoluteImplementsYangModels(Arrays.asList(
  90                 "src/test/resources/model-yangdom/basic-parsing-test/block-comments.yang"));
  91         assertNoFindings();
  92
  93         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
  94         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("block-comments-module").size() == 1);
  95     }
  96
  97     @Test
  98     public void test_line_comments() {
  99         parseAbsoluteImplementsYangModels(Arrays.asList(
 100                 "src/test/resources/model-yangdom/basic-parsing-test/line-comments.yang"));
 101         assertNoFindings();
 102
 103         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
 104         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("line-comment-module").size() == 1);
 105     }
 106
 107     @Test
 108     public void test_simple_module() {
 109         parseAbsoluteImplementsYangModels(Arrays.asList(
 110                 "src/test/resources/model-yangdom/basic-parsing-test/simple-module.yang"));
 111
 112         final YModule simpleModule = getModule("simple-module");
 113         assertTrue(simpleModule != null);
 114
 115         final YangDomElement moduleDomElement = simpleModule.getDomElement();
 116         assertTrue(moduleDomElement.toString().equals("module simple-module"));
 117         assertTrue(moduleDomElement.hashCode() == "'module simple-module'".hashCode());
 118         assertTrue(moduleDomElement.getTrimmedValueOrNull().equals("simple-module"));
 119
 120         final YRpc rpc1 = getRpc(simpleModule, "rpc1");
 121         assertTrue(rpc1.getDomElement().getNameValue().equals("'rpc rpc1'"));
 122         assertTrue(rpc1.getDomElement().getNameValue().equals("'rpc rpc1'"));
 123
 124         final YInput input1 = rpc1.getInput();
 125         assertTrue(input1.getDomElement().getNameValue().equals("'input'"));
 126         assertTrue(input1.getDomElement().getNameValue().equals("'input'"));
 127         assertTrue(input1.getDomElement().getTrimmedValueOrNull() == null);
 128         assertTrue(input1.getDomElement().getParentElement() == rpc1.getDomElement());
 129
 130         assertTrue(input1.getDomElement().getChildren().size() == 2);
 131         input1.getDomElement().getChildren().get(1).remove();
 132         assertTrue(input1.getDomElement().getChildren().size() == 1);
 133         assertTrue(input1.getDomElement().getChildren().get(0).getValue().equals("leaf1"));
 134
 135         assertTrue(input1.getDomElement().getSimplifiedPath().equals("/module=simple-module/rpc=rpc1/input"));
 136
 137         final YLeaf leaf4 = getLeaf(simpleModule, "leaf4");
 138         assertTrue(leaf4.getDomElement().getSimplifiedPath().equals("/module=simple-module/leaf=leaf4"));
 139
 140         assertTrue(leaf4.getWhens().get(0).getDomElement().getSimplifiedPath().equals(
 141                 "/module=simple-module/leaf=leaf4/when=(../leaf3)"));
 142
 143         assertTrue(getLeaf(simpleModule, "leaf5").getDescription().getValue().equals("Hello World"));
 144         assertTrue(getLeaf(simpleModule, "leaf6").getDescription().getValue().equals("Hello World"));
 145         assertTrue(getLeaf(simpleModule, "leaf7").getDescription().getValue().equals("Hello World!"));
 146     }
 147
 148     @Test
 149     public void test_multiple_semicolons() {
 150         parseAbsoluteImplementsYangModels(Arrays.asList(
 151                 "src/test/resources/model-yangdom/basic-parsing-test/multiple-semicolons.yang"));
 152         assertHasFindingOfType(ParserFindingType.P055_SUPERFLUOUS_STATEMENT.toString());
 153
 154         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
 155         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("multiple-semicolons").size() == 1);
 156     }
 157
 158     @Test
 159     public void test_multiple_plus() {
 160         parseAbsoluteImplementsYangModels(Arrays.asList(
 161                 "src/test/resources/model-yangdom/basic-parsing-test/multiple-plus.yang"));
 162         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 163
 164         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
 165     }
 166
 167     @Test
 168     public void test_quoted_plus_unquoted() {
 169         parseAbsoluteImplementsYangModels(Arrays.asList(
 170                 "src/test/resources/model-yangdom/basic-parsing-test/quoted-plus-unquoted.yang"));
 171         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 172
 173         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
 174     }
 175
 176     @Test
 177     public void test_unquoted_plus_unquoted() {
 178         parseAbsoluteImplementsYangModels(Arrays.asList(
 179                 "src/test/resources/model-yangdom/basic-parsing-test/unquoted-plus-unquoted.yang"));
 180         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 181
 182         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
 183     }
 184
 185     @Test
 186     public void test_document_end_missing() {
 187         parseAbsoluteImplementsYangModels(Arrays.asList(
 188                 "src/test/resources/model-yangdom/basic-parsing-test/document-end-missing.yang"));
 189         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
 190
 191         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 1);
 192     }
 193
 194     @Test
 195     public void test_double_left_brace() {
 196         parseAbsoluteImplementsYangModels(Arrays.asList(
 197                 "src/test/resources/model-yangdom/basic-parsing-test/double-left-brace.yang"));
 198         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 199     }
 200
 201     @Test
 202     public void test_three_statements() {
 203         parseAbsoluteImplementsYangModels(Arrays.asList(
 204                 "src/test/resources/model-yangdom/basic-parsing-test/three-statements.yang"));
 205         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 206     }
 207
 208     @Test
 209     public void test_mult_statements_at_root() {
 210         parseAbsoluteImplementsYangModels(Arrays.asList(
 211                 "src/test/resources/model-yangdom/basic-parsing-test/multiple-statements-at-root.yang"));
 212         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
 213
 214         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
 215     }
 216
 217     @Test
 218     public void test_weird_root() {
 219         parseAbsoluteImplementsYangModels(Arrays.asList(
 220                 "src/test/resources/model-yangdom/basic-parsing-test/weird-root.yang"));
 221         assertHasFindingOfType(ParserFindingType.P013_INVALID_SYNTAX_AT_DOCUMENT_ROOT.toString());
 222
 223         assertTrue(yangDeviceModel.getModuleRegistry().getAllYangModels().size() == 0);
 224     }
 225
 226     @Test
 227     public void test_missing_and_ducplicate_statements() {
 228         parseAbsoluteImplementsYangModels(Arrays.asList(
 229                 "src/test/resources/model-yangdom/basic-parsing-test/missing-and-duplicate-statements.yang"));
 230
 231         final YModule module = getModule("missing-and-duplicate-statements");
 232         assertTrue(module != null);
 233
 234         final YContainer cont1 = getContainer(module, "cont1");
 235         assertDomElementHasFindingOfType(cont1.getDomElement(), ParserFindingType.P018_ILLEGAL_CHILD_STATEMENT.toString());
 236
 237         final YLeaf leaf1 = getLeaf(cont1, "leaf1");
 238         assertDomElementHasFindingOfType(leaf1.getDomElement(), ParserFindingType.P018_ILLEGAL_CHILD_STATEMENT.toString());
 239         assertStatementHasFindingOfType(leaf1.getMandatory(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 240
 241         final YLeaf leaf2 = getLeaf(cont1, "leaf2");
 242         assertStatementHasFindingOfType(leaf2.getType().getBases().get(0), ParserFindingType.P052_INVALID_YANG_IDENTIFIER
 243                 .toString());
 244
 245         final YLeaf leaf3 = getLeaf(cont1, "leaf3");
 246         assertStatementHasFindingOfType(leaf3.getMandatory(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 247
 248         final YContainer contWithWeirdCharacters = getContainer(module, "cont2_with_weird_%%_characters");
 249         assertStatementHasFindingOfType(contWithWeirdCharacters, ParserFindingType.P052_INVALID_YANG_IDENTIFIER.toString());
 250
 251         final YContainer cont3 = getContainer(module, "cont3");
 252         assertDomElementHasFindingOfType(cont3.getDomElement().getChildren().get(0),
 253                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 254         assertDomElementHasFindingOfType(cont3.getDomElement().getChildren().get(1),
 255                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 256
 257         assertStatementHasFindingOfType(module.getDeviations().get(0),
 258                 ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT.toString());
 259     }
 260
 261     @Test
 262     public void test_missing_import_name() {
 263         parseAbsoluteImplementsYangModels(Arrays.asList(
 264                 "src/test/resources/model-yangdom/basic-parsing-test/missing-import-name.yang"));
 265
 266         final YModule module = getModule("missing-import-name");
 267         assertTrue(module != null);
 268
 269         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-import-name").size() == 1);
 270
 271         assertStatementHasFindingOfType(module.getImports().get(0), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 272                 .toString());
 273     }
 274
 275     @Test
 276     public void test_missing_prefix_under_import() {
 277         parseAbsoluteImplementsYangModels(Arrays.asList(
 278                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix-under-import.yang",
 279                 "src/test/resources/model-yangdom/basic-parsing-test/basic-empty-module.yang"));
 280
 281         final YModule module = getModule("missing-prefix-under-import");
 282         assertTrue(module != null);
 283
 284         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-prefix-under-import").size() == 1);
 285         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-empty-module").size() == 1);
 286
 287         assertStatementHasFindingOfType(module.getImports().get(0), ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT
 288                 .toString());
 289     }
 290
 291     @Test
 292     public void test_missing_prefix_name_under_import() {
 293         parseAbsoluteImplementsYangModels(Arrays.asList(
 294                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix-name-under-import.yang",
 295                 "src/test/resources/model-yangdom/basic-parsing-test/basic-empty-module.yang"));
 296
 297         final YModule module = getModule("missing-prefix-name-under-import");
 298         assertTrue(module != null);
 299
 300         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-prefix-name-under-import").size() == 1);
 301         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-empty-module").size() == 1);
 302
 303         assertStatementHasFindingOfType(module.getImports().get(0).getPrefix(),
 304                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 305     }
 306
 307     @Test
 308     public void test_missing_include_name() {
 309         parseAbsoluteImplementsYangModels(Arrays.asList(
 310                 "src/test/resources/model-yangdom/basic-parsing-test/missing-include-name.yang"));
 311
 312         final YModule module = getModule("missing-include-name");
 313         assertTrue(module != null);
 314
 315         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-include-name").size() == 1);
 316
 317         assertStatementHasFindingOfType(module.getIncludes().get(0), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 318                 .toString());
 319     }
 320
 321     @Test
 322     public void test_missing_belongsto() {
 323         parseAbsoluteImplementsYangModels(Arrays.asList(
 324                 "src/test/resources/model-yangdom/basic-parsing-test/basic-module-including.yang",
 325                 "src/test/resources/model-yangdom/basic-parsing-test/missing-belongsto.yang"));
 326
 327         final YModule module = getModule("basic-module-including");
 328         assertTrue(module != null);
 329         final YSubmodule submodule = getSubModule("basic-submodule");
 330         assertTrue(submodule != null);
 331
 332         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-module-including").size() == 1);
 333         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-submodule").size() == 1);
 334
 335         assertStatementHasFindingOfType(submodule, ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT.toString());
 336     }
 337
 338     @Test
 339     public void test_missing_belongsto_name() {
 340         parseAbsoluteImplementsYangModels(Arrays.asList(
 341                 "src/test/resources/model-yangdom/basic-parsing-test/basic-module-including.yang",
 342                 "src/test/resources/model-yangdom/basic-parsing-test/missing-belongsto-name.yang"));
 343
 344         final YModule module = getModule("basic-module-including");
 345         assertTrue(module != null);
 346         final YSubmodule submodule = getSubModule("basic-submodule");
 347         assertTrue(submodule != null);
 348
 349         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-module-including").size() == 1);
 350         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-submodule").size() == 1);
 351
 352         assertStatementHasFindingOfType(submodule.getBelongsTo(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 353                 .toString());
 354     }
 355
 356     @Test
 357     public void test_missing_prefix_under_belongsto() {
 358         parseAbsoluteImplementsYangModels(Arrays.asList(
 359                 "src/test/resources/model-yangdom/basic-parsing-test/basic-module-including.yang",
 360                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix-under-belongsto.yang"));
 361
 362         final YModule module = getModule("basic-module-including");
 363         assertTrue(module != null);
 364         final YSubmodule submodule = getSubModule("basic-submodule");
 365         assertTrue(submodule != null);
 366
 367         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-module-including").size() == 1);
 368         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-submodule").size() == 1);
 369
 370         assertStatementHasFindingOfType(submodule.getBelongsTo(), ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT
 371                 .toString());
 372     }
 373
 374     @Test
 375     public void test_missing_prefix_name_under_belongsto() {
 376         parseAbsoluteImplementsYangModels(Arrays.asList(
 377                 "src/test/resources/model-yangdom/basic-parsing-test/basic-module-including.yang",
 378                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix-name-under-belongsto.yang"));
 379
 380         final YModule module = getModule("basic-module-including");
 381         assertTrue(module != null);
 382         final YSubmodule submodule = getSubModule("basic-submodule");
 383         assertTrue(submodule != null);
 384
 385         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-module-including").size() == 1);
 386         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("basic-submodule").size() == 1);
 387
 388         assertStatementHasFindingOfType(submodule.getBelongsTo().getPrefix(),
 389                 ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 390     }
 391
 392     @Test
 393     public void test_missing_prefix() {
 394         parseAbsoluteImplementsYangModels(Arrays.asList(
 395                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix.yang"));
 396
 397         final YModule module = getModule("missing-prefix");
 398         assertTrue(module != null);
 399
 400         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-prefix").size() == 1);
 401
 402         assertStatementHasFindingOfType(module, ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT.toString());
 403     }
 404
 405     @Test
 406     public void test_missing_prefix_name() {
 407         parseAbsoluteImplementsYangModels(Arrays.asList(
 408                 "src/test/resources/model-yangdom/basic-parsing-test/missing-prefix-name.yang"));
 409
 410         final YModule module = getModule("missing-prefix-name");
 411         assertTrue(module != null);
 412
 413         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-prefix-name").size() == 1);
 414
 415         assertStatementHasFindingOfType(module.getPrefix(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 416         assertFindingCount(1);
 417     }
 418
 419     @Test
 420     public void test_missing_namespace() {
 421         parseAbsoluteImplementsYangModels(Arrays.asList(
 422                 "src/test/resources/model-yangdom/basic-parsing-test/missing-namespace.yang"));
 423
 424         final YModule module = getModule("missing-namespace");
 425         assertTrue(module != null);
 426
 427         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-namespace").size() == 1);
 428
 429         assertStatementHasFindingOfType(module, ParserFindingType.P019_MISSING_REQUIRED_CHILD_STATEMENT.toString());
 430         assertFindingCount(1);
 431     }
 432
 433     @Test
 434     public void test_missing_namespace_name() {
 435         parseAbsoluteImplementsYangModels(Arrays.asList(
 436                 "src/test/resources/model-yangdom/basic-parsing-test/missing-namespace-name.yang"));
 437
 438         final YModule module = getModule("missing-namespace-name");
 439         assertTrue(module != null);
 440
 441         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-namespace-name").size() == 1);
 442
 443         assertStatementHasFindingOfType(module.getNamespace(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 444                 .toString());
 445         assertFindingCount(1);
 446     }
 447
 448     @Test
 449     public void test_missing_yangversion_version() {
 450         parseAbsoluteImplementsYangModels(Arrays.asList(
 451                 "src/test/resources/model-yangdom/basic-parsing-test/missing-yangversion-version.yang"));
 452
 453         final YModule module = getModule("missing-yangversion-version");
 454         assertTrue(module != null);
 455
 456         assertTrue(yangDeviceModel.getModuleRegistry().byModuleName("missing-yangversion-version").size() == 1);
 457
 458         assertStatementHasFindingOfType(module.getYangVersion(), ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT
 459                 .toString());
 460         assertFindingCount(1);
 461     }
 462
 463     @Test
 464     public void test_dangling_block_comment() {
 465         parseAbsoluteImplementsYangModels(Arrays.asList(
 466                 "src/test/resources/model-yangdom/basic-parsing-test/dangling-block-comment.yang"));
 467         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
 468     }
 469
 470     @Test
 471     public void test_dangling_double_quote() {
 472         parseAbsoluteImplementsYangModels(Arrays.asList(
 473                 "src/test/resources/model-yangdom/basic-parsing-test/dangling-double-quote.yang"));
 474         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
 475     }
 476
 477     @Test
 478     public void test_dangling_single_quote() {
 479         parseAbsoluteImplementsYangModels(Arrays.asList(
 480                 "src/test/resources/model-yangdom/basic-parsing-test/dangling-single-quote.yang"));
 481         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
 482     }
 483
 484     @Test
 485     public void test_dangling_plus_token() {
 486         parseAbsoluteImplementsYangModels(Arrays.asList(
 487                 "src/test/resources/model-yangdom/basic-parsing-test/dangling-plus-token.yang"));
 488         assertHasFindingOfType(ParserFindingType.P014_INVALID_SYNTAX_AT_DOCUMENT_END.toString());
 489     }
 490
 491     @Test
 492     public void test_incorrect_string_concatenation() {
 493         parseAbsoluteImplementsYangModels(Arrays.asList(
 494                 "src/test/resources/model-yangdom/basic-parsing-test/incorrect-string-concatenation.yang"));
 495         assertHasFindingOfType(ParserFindingType.P015_INVALID_SYNTAX_IN_DOCUMENT.toString());
 496     }
 497
 498 }