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.findings.test;
  22
  23 import static org.junit.Assert.assertTrue;
  24
  25 import java.io.File;
  26 import java.util.ArrayList;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.Set;
  30
  31 import org.junit.Before;
  32 import org.junit.Test;
  33
  34 import org.oran.smo.yangtools.parser.ParserExecutionContext;
  35 import org.oran.smo.yangtools.parser.YangDeviceModel;
  36 import org.oran.smo.yangtools.parser.findings.Finding;
  37 import org.oran.smo.yangtools.parser.findings.FindingSeverity;
  38 import org.oran.smo.yangtools.parser.findings.FindingsManager;
  39 import org.oran.smo.yangtools.parser.findings.ModifyableFindingSeverityCalculator;
  40 import org.oran.smo.yangtools.parser.findings.ModuleAndFindingTypeAndSchemaNodePathFilterPredicate;
  41 import org.oran.smo.yangtools.parser.findings.ModuleAndSeverityFilterPredicate;
  42 import org.oran.smo.yangtools.parser.findings.ParserFindingType;
  43 import org.oran.smo.yangtools.parser.input.FileBasedYangInput;
  44 import org.oran.smo.yangtools.parser.model.ConformanceType;
  45 import org.oran.smo.yangtools.parser.model.YangModel;
  46 import org.oran.smo.yangtools.parser.model.statements.yang.YLeaf;
  47
  48 public class FindingsManagerTest {
  49
  50     private YangDeviceModel yangDeviceModel;
  51     private ModifyableFindingSeverityCalculator severityCalculator;
  52     private FindingsManager findingsManager;
  53     private ParserExecutionContext context;
  54
  55     @Before
  56     public void setUp() {
  57         yangDeviceModel = new YangDeviceModel("Yang Parser JAR Test Device Model");
  58         severityCalculator = new ModifyableFindingSeverityCalculator();
  59         findingsManager = new FindingsManager(severityCalculator);
  60         context = new ParserExecutionContext(findingsManager);
  61
  62         final List<YangModel> yangFiles = new ArrayList<>();
  63         yangFiles.add(new YangModel(new FileBasedYangInput(new File("src/test/resources/findings/module1.yang")),
  64                 ConformanceType.IMPLEMENT));
  65         yangDeviceModel.parseIntoYangModels(context, yangFiles);
  66     }
  67
  68     @Test
  69     public void test_severity_calculator() {
  70
  71         final ModifyableFindingSeverityCalculator severityCalculator = new ModifyableFindingSeverityCalculator();
  72
  73         severityCalculator.errorForFinding(ParserFindingType.P101_EMPTY_DOCUMENTATION_VALUE.toString());
  74         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
  75         severityCalculator.infoForFinding(ParserFindingType.P103_ILLEGAL_IF_FEATURE_SYNTAX.toString());
  76         severityCalculator.suppressFinding(ParserFindingType.P104_USAGE_OF_DEPRECATED_ELEMENT.toString());
  77
  78         severityCalculator.setSeverityForFindingType(ParserFindingType.P111_CIRCULAR_TYPEDEF_REFERENCES.toString(),
  79                 FindingSeverity.WARNING);
  80
  81         assertTrue(severityCalculator.calculateSeverity("something else") == FindingSeverity.ERROR);
  82
  83         assertTrue(severityCalculator.calculateSeverity(ParserFindingType.P101_EMPTY_DOCUMENTATION_VALUE
  84                 .toString()) == FindingSeverity.ERROR);
  85         assertTrue(severityCalculator.calculateSeverity(ParserFindingType.P102_INVALID_STATUS
  86                 .toString()) == FindingSeverity.WARNING);
  87         assertTrue(severityCalculator.calculateSeverity(ParserFindingType.P103_ILLEGAL_IF_FEATURE_SYNTAX
  88                 .toString()) == FindingSeverity.INFO);
  89         assertTrue(severityCalculator.calculateSeverity(ParserFindingType.P104_USAGE_OF_DEPRECATED_ELEMENT
  90                 .toString()) == FindingSeverity.SUPPRESS);
  91
  92         assertTrue(severityCalculator.calculateSeverity(ParserFindingType.P111_CIRCULAR_TYPEDEF_REFERENCES
  93                 .toString()) == FindingSeverity.WARNING);
  94     }
  95
  96     @Test
  97     public void test_fine_grained_2options_all() {
  98
  99         addFineGrainedFilter("*;*");
 100
 101         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 102                 .getLeafs().get(0);
 103
 104         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 105         assertTrue(findingsManager.getAllFindings().size() == 0);
 106     }
 107
 108     @Test
 109     public void test_fine_grained_2options_module1() {
 110
 111         addFineGrainedFilter("module1;*");
 112
 113         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 114                 .getLeafs().get(0);
 115
 116         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 117         assertTrue(findingsManager.getAllFindings().size() == 0);
 118     }
 119
 120     @Test
 121     public void test_fine_grained_2options_mod_star() {
 122
 123         addFineGrainedFilter("mod*;*");
 124
 125         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 126                 .getLeafs().get(0);
 127
 128         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 129         assertTrue(findingsManager.getAllFindings().size() == 0);
 130     }
 131
 132     @Test
 133     public void test_fine_grained_2options_module1_and_others() {
 134
 135         addFineGrainedFilter("module1,module2;*");
 136
 137         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 138                 .getLeafs().get(0);
 139
 140         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 141         assertTrue(findingsManager.getAllFindings().size() == 0);
 142     }
 143
 144     @Test
 145     public void test_fine_grained_2options_moduleXXX_all() {
 146
 147         addFineGrainedFilter("moduleXXX;*");
 148
 149         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 150                 .getLeafs().get(0);
 151
 152         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 153         assertTrue(findingsManager.getAllFindings().size() == 1);
 154     }
 155
 156     @Test
 157     public void test_fine_grained_2options_warnings() {
 158
 159         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 160
 161         addFineGrainedFilter("*;WARNING");
 162
 163         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 164                 .getLeafs().get(0);
 165
 166         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 167         assertTrue(findingsManager.getAllFindings().size() == 0);
 168     }
 169
 170     @Test
 171     public void test_fine_grained_2options_info() {
 172
 173         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 174
 175         addFineGrainedFilter("*;INFO");
 176
 177         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 178                 .getLeafs().get(0);
 179
 180         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 181         assertTrue(findingsManager.getAllFindings().size() == 1);
 182     }
 183
 184     @Test
 185     public void test_fine_grained_2options_warnings_info() {
 186
 187         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 188
 189         addFineGrainedFilter("*;WARNING,INFO");
 190
 191         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 192                 .getLeafs().get(0);
 193
 194         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 195         assertTrue(findingsManager.getAllFindings().size() == 0);
 196     }
 197
 198     @Test
 199     public void test_fine_grained_2options_module1_warnings() {
 200
 201         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 202
 203         addFineGrainedFilter("module1;WARNING");
 204
 205         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 206                 .getLeafs().get(0);
 207
 208         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 209         assertTrue(findingsManager.getAllFindings().size() == 0);
 210     }
 211
 212     @Test
 213     public void test_fine_grained_2options_moduleXXX_warnings() {
 214
 215         severityCalculator.warningForFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 216
 217         addFineGrainedFilter("moduleXXX;WARNING");
 218
 219         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 220                 .getLeafs().get(0);
 221
 222         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 223         assertTrue(findingsManager.getAllFindings().size() == 1);
 224     }
 225
 226     @Test
 227     public void test_fine_grained_3options_all() {
 228
 229         addFineGrainedFilter("*;*;*");
 230
 231         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 232                 .getLeafs().get(0);
 233
 234         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 235         assertTrue(findingsManager.getAllFindings().size() == 0);
 236     }
 237
 238     @Test
 239     public void test_fine_grained_3options_module1() {
 240
 241         addFineGrainedFilter("module1;*;*");
 242
 243         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 244                 .getLeafs().get(0);
 245
 246         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 247         assertTrue(findingsManager.getAllFindings().size() == 0);
 248     }
 249
 250     @Test
 251     public void test_fine_grained_3options_module1_moduleXXX() {
 252
 253         addFineGrainedFilter("module1,moduleXXX;*;*");
 254
 255         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 256                 .getLeafs().get(0);
 257
 258         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 259         assertTrue(findingsManager.getAllFindings().size() == 0);
 260     }
 261
 262     @Test
 263     public void test_fine_grained_3options_moduleXXX() {
 264
 265         addFineGrainedFilter("moduleXXX;*;*");
 266
 267         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 268                 .getLeafs().get(0);
 269
 270         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 271         assertTrue(findingsManager.getAllFindings().size() == 1);
 272     }
 273
 274     @Test
 275     public void test_fine_grained_3options_mod_star() {
 276
 277         addFineGrainedFilter("mod*;*;*");
 278
 279         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 280                 .getLeafs().get(0);
 281
 282         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 283         assertTrue(findingsManager.getAllFindings().size() == 0);
 284     }
 285
 286     @Test
 287     public void test_fine_grained_3options_invalidstatus() {
 288
 289         addFineGrainedFilter("*;P102_INVALID_STATUS;*");
 290
 291         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 292                 .getLeafs().get(0);
 293
 294         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 295         assertTrue(findingsManager.getAllFindings().size() == 0);
 296     }
 297
 298     @Test
 299     public void test_fine_grained_3options_p1_star() {
 300
 301         addFineGrainedFilter("*;P1*;*");
 302
 303         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 304                 .getLeafs().get(0);
 305
 306         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 307         assertTrue(findingsManager.getAllFindings().size() == 0);
 308     }
 309
 310     @Test
 311     public void test_fine_grained_3options_p0_star() {
 312
 313         addFineGrainedFilter("*;P0*;*");
 314
 315         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 316                 .getLeafs().get(0);
 317
 318         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 319         assertTrue(findingsManager.getAllFindings().size() == 1);
 320     }
 321
 322     @Test
 323     public void test_fine_grained_3options_p000_star_invalidstatus() {
 324
 325         addFineGrainedFilter("*;P000*,P102_INVALID_STATUS;*");
 326
 327         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 328                 .getLeafs().get(0);
 329
 330         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 331         assertTrue(findingsManager.getAllFindings().size() == 0);
 332     }
 333
 334     @Test
 335     public void test_fine_grained_3options_module1_p1_star() {
 336
 337         addFineGrainedFilter("module1;P1*;*");
 338
 339         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 340                 .getLeafs().get(0);
 341
 342         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 343         assertTrue(findingsManager.getAllFindings().size() == 0);
 344     }
 345
 346     @Test
 347     public void test_fine_grained_3options_moduleXXX_p1_star() {
 348
 349         addFineGrainedFilter("moduleXXX;P1*;*");
 350
 351         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 352                 .getLeafs().get(0);
 353
 354         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 355         assertTrue(findingsManager.getAllFindings().size() == 1);
 356     }
 357
 358     @Test
 359     public void test_fine_grained_3options_moduelXXX_p1_star() {
 360
 361         addFineGrainedFilter("moduleXXX;P1*;*");
 362
 363         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 364                 .getLeafs().get(0);
 365
 366         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 367         assertTrue(findingsManager.getAllFindings().size() == 1);
 368     }
 369
 370     @Test
 371     public void test_fine_grained_3options_path_module_module1() {
 372
 373         addFineGrainedFilter("*;*;/module=module1");
 374
 375         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 376                 .getLeafs().get(0);
 377
 378         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 379         assertTrue(findingsManager.getAllFindings().size() == 0);
 380     }
 381
 382     @Test
 383     public void test_fine_grained_3options_path_module_moduleXXX() {
 384
 385         addFineGrainedFilter("*;*;/module=moduleXXX");
 386
 387         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 388                 .getLeafs().get(0);
 389
 390         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 391         assertTrue(findingsManager.getAllFindings().size() == 1);
 392     }
 393
 394     @Test
 395     public void test_fine_grained_3options_path_module_module1_leaf_leaf1() {
 396
 397         addFineGrainedFilter("*;*;/module=module1/leaf=leaf1");
 398
 399         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 400                 .getLeafs().get(0);
 401
 402         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 403         assertTrue(findingsManager.getAllFindings().size() == 0);
 404     }
 405
 406     @Test
 407     public void test_fine_grained_3options_path_module_module1_leaf_leaf2() {
 408
 409         addFineGrainedFilter("*;*;/module=module1/leaf=leaf2");
 410
 411         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 412                 .getLeafs().get(0);
 413
 414         findingsManager.addFinding(new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 415         assertTrue(findingsManager.getAllFindings().size() == 1);
 416     }
 417
 418     @Test
 419     public void test_fine_grained_3options_path_module_module1_leaf_leaf1_not_on_leaf() {
 420
 421         addFineGrainedFilter("*;*;/module=module1/leaf=leaf1");
 422
 423         findingsManager.addFinding(new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "message"));
 424         assertTrue(findingsManager.getAllFindings().size() == 1);
 425     }
 426
 427     @Test
 428     public void test_finding_general_finding() {
 429
 430         final Finding finding1 = new Finding(ParserFindingType.P101_EMPTY_DOCUMENTATION_VALUE.toString(), "Missing Value");
 431         final Finding finding2 = new Finding(ParserFindingType.P101_EMPTY_DOCUMENTATION_VALUE.toString(), "Missing Value");
 432
 433         final Finding finding3 = new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "Missing Value");
 434         final Finding finding4 = new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "Other Missing Value");
 435
 436         assertTrue(finding1.getDataDomNode() == null);
 437         assertTrue(finding1.getFindingType().equals(ParserFindingType.P101_EMPTY_DOCUMENTATION_VALUE.toString()));
 438         assertTrue(finding1.getLineNumber() == 0);
 439         assertTrue(finding1.getMessage().equals("Missing Value"));
 440         assertTrue(finding1.getStatement() == null);
 441         assertTrue(finding1.getYangData() == null);
 442         assertTrue(finding1.getYangModel() == null);
 443
 444         assertTrue(finding1.isYangModelRelated() == false);
 445         assertTrue(finding1.isInstanceDataRelated() == false);
 446         assertTrue(finding1.isGeneralFinding() == true);
 447         assertTrue(finding1.toString().equals(" P101_EMPTY_DOCUMENTATION_VALUE: Missing Value"));
 448
 449         assertTrue(finding1.equals(null) == false);
 450         assertTrue(finding1.equals(finding2) == true);
 451         assertTrue(finding1.equals(finding3) == false);
 452         assertTrue(finding3.equals(finding4) == false);
 453     }
 454
 455     @Test
 456     public void test_finding_module_finding() {
 457
 458         final YLeaf leaf1 = yangDeviceModel.getModuleRegistry().getAllYangModels().get(0).getYangModelRoot().getModule()
 459                 .getLeafs().get(0);
 460
 461         final Finding finding8 = new Finding(leaf1, ParserFindingType.P102_INVALID_STATUS.toString(), "message");
 462
 463         assertTrue(finding8.getDataDomNode() == null);
 464         assertTrue(finding8.getFindingType().equals(ParserFindingType.P102_INVALID_STATUS.toString()));
 465         assertTrue(finding8.getLineNumber() == 14);
 466         assertTrue(finding8.getMessage().equals("message"));
 467         assertTrue(finding8.getStatement() == leaf1);
 468         assertTrue(finding8.getYangData() == null);
 469         assertTrue(finding8.getYangModel() == yangDeviceModel.getModuleRegistry().getAllYangModels().get(0));
 470
 471         assertTrue(finding8.isYangModelRelated() == true);
 472         assertTrue(finding8.isInstanceDataRelated() == false);
 473         assertTrue(finding8.isGeneralFinding() == false);
 474         assertTrue(finding8.toString().equals("module1.yang / line 14 P102_INVALID_STATUS: message"));
 475     }
 476
 477     @Test
 478     public void test_getFiltered_allow_all() {
 479
 480         final Finding finding1 = new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "message");
 481         Set<Finding> findings = Collections.singleton(finding1);
 482
 483         final Set<Finding> filteredFindings = findingsManager.getFilteredFindings(findings);
 484
 485         assertTrue(filteredFindings.size() == 1);
 486     }
 487
 488     @Test
 489     public void test_getFiltered_suppless_all() {
 490
 491         final Finding finding1 = new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "message");
 492         Set<Finding> findings = Collections.singleton(finding1);
 493
 494         findingsManager.setSuppressAll(true);
 495         final Set<Finding> filteredFindings = findingsManager.getFilteredFindings(findings);
 496
 497         assertTrue(filteredFindings.size() == 0);
 498     }
 499
 500     @Test
 501     public void test_getFiltered_suppless_invalid_status() {
 502
 503         final Finding finding1 = new Finding(ParserFindingType.P102_INVALID_STATUS.toString(), "message");
 504         Set<Finding> findings = Collections.singleton(finding1);
 505
 506         severityCalculator.suppressFinding(ParserFindingType.P102_INVALID_STATUS.toString());
 507         final Set<Finding> filteredFindings = findingsManager.getFilteredFindings(findings);
 508
 509         assertTrue(filteredFindings.size() == 0);
 510     }
 511
 512     private void addFineGrainedFilter(final String filterString) {
 513         if (filterString.split(";").length == 2) {
 514             findingsManager.addFilterPredicate(ModuleAndSeverityFilterPredicate.fromString(filterString, findingsManager
 515                     .getFindingSeverityCalculator()));
 516         } else {
 517             findingsManager.addFilterPredicate(ModuleAndFindingTypeAndSchemaNodePathFilterPredicate.fromString(
 518                     filterString));
 519         }
 520     }
 521 }