How to use

org.batfish.datamodel.answers.Issue$Type

constructor

@JsonCreator
private static Type createType(
  @JsonProperty(PROP_MAJOR) String major, @JsonProperty(PROP_MINOR) String minor) {
 return new Type(firstNonNull(major, ""), firstNonNull(minor, ""));
}

@Test
public void testApplyRowIssuesConfigurationNoMatchMajorIssue() {
 String col = "col";
 String major = "major";
 String otherMajor = "otherMajor";
 String minor = "minor";
 Row oldRow = Row.of(col, new Issue("explanation", 5, new Issue.Type(major, minor)));
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     otherMajor,
     new MajorIssueConfig(
       otherMajor, ImmutableList.of(new MinorIssueConfig(minor, 6, "example.com"))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs), equalTo(oldRow));
}

@Test
public void testApplyRowIssuesConfigurationNoMatchMinorIssue() {
 String col = "col";
 String major = "major";
 String otherMinor = "otherMinor";
 String minor = "minor";
 Row oldRow = Row.of(col, new Issue("explanation", 5, new Issue.Type(major, minor)));
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     major,
     new MajorIssueConfig(
       major, ImmutableList.of(new MinorIssueConfig(otherMinor, 6, "example.com"))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs), equalTo(oldRow));
}

  new TableAnswerElement(
    new TableMetadata(ImmutableList.of(new ColumnMetadata(col, Schema.ISSUE, "desc"))));
oldTable.addRow(Row.of(col, new Issue("blah", 1, new Issue.Type(major, minor))));
oldTable.addExcludedRow(
  Row.of(col, new Issue("blorp", 1, new Issue.Type(major, minor))), "exc");
oldAnswer.setAnswerElements(ImmutableList.of(oldTable));
AnswerMetadata oldAnswerMetadata =
      BatfishObjectMapper.mapper()
        .valueToTree(
          Row.of(col, new Issue("blorp", 1, new Issue.Type(major, minor)))))));
String questionContent = BatfishObjectMapper.writeString(testQuestion);
_storage.storeQuestion(questionContent, networkId, questionId, analysisId);

String minor = "minor";
int severity = 1;
Issue issueValue = new Issue("a", severity, new Issue.Type(major, minor));

    new TableMetadata(
      ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
Answer answer = new Answer();
answer.addAnswerElement(table);

1,
colIssue,
new Issue("blah", 1, new Issue.Type("major", "minor")),
colString,
"a");
2,
colIssue,
new Issue("blah", 2, new Issue.Type("major", "minor")),
colString,
"b");

@Test
public void testProcessAnswerRows() throws IOException {
 String columnName = "issue";
 int maxRows = 1;
 int rowOffset = 0;
 TableAnswerElement table =
   new TableAnswerElement(
     new TableMetadata(
       ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
 table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
 Answer answer = new Answer();
 answer.addAnswerElement(table);
 answer.setStatus(AnswerStatus.SUCCESS);
 String answerStr = BatfishObjectMapper.writePrettyString(answer);
 AnswerRowsOptions options =
   new AnswerRowsOptions(
     ImmutableSet.of(columnName),
     ImmutableList.of(),
     maxRows,
     rowOffset,
     ImmutableList.of(new ColumnSortOption(columnName, true)),
     false);
 List<Row> processedRows =
   ((TableAnswerElement)
       _manager.processAnswerRows(answerStr, options).getAnswerElements().get(0))
     .getRowsList();
 assertThat(processedRows, equalTo(table.getRowsList()));
}

@Test
public void testProcessAnswerRows2() throws IOException {
 String columnName = "issue";
 int maxRows = 1;
 int rowOffset = 0;
 TableAnswerElement table =
   new TableAnswerElement(
     new TableMetadata(
       ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar"))));
 table.addRow(Row.of(columnName, new Issue("blah", 5, new Issue.Type("m", "n"))));
 Answer answer = new Answer();
 answer.addAnswerElement(table);
 answer.setStatus(AnswerStatus.SUCCESS);
 String answerStr = BatfishObjectMapper.writePrettyString(answer);
 AnswerRowsOptions options =
   new AnswerRowsOptions(
     ImmutableSet.of(columnName),
     ImmutableList.of(),
     maxRows,
     rowOffset,
     ImmutableList.of(new ColumnSortOption(columnName, true)),
     false);
 List<Row> processedRows =
   ((TableView) _manager.processAnswerRows2(answerStr, options).getAnswerElements().get(0))
     .getInnerRows();
 assertThat(processedRows, equalTo(table.getRowsList()));
}

 @Test
 public void testComputeMajorIssueTypesSome() {
  String columnName = "col";
  String major = "major";
  String minor = "minor";
  int severity = 5;
  Issue value = new Issue("a", severity, new Issue.Type(major, minor));

  TableAnswerElement table =
    new TableAnswerElement(
        new TableMetadata(
          ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar")),
          new DisplayHints().getTextDesc()))
      .addRow(Row.of(columnName, value));

  assertThat(
    AnswerMetadataUtil.computeMajorIssueConfigs(table),
    equalTo(
      ImmutableMap.of(
        major,
        new MajorIssueConfig(
          major, ImmutableMap.of(minor, new MinorIssueConfig(minor, severity, null))))));
 }
}

@Test
public void testApplyRowIssuesConfigurationMatch() {
 String col = "col";
 String major = "major";
 String minor = "minor";
 Issue oldIssue = new Issue("explanation", 5, new Issue.Type(major, minor));
 Row oldRow = Row.of(col, oldIssue);
 int newSeverity = 6;
 String newUrl = "example.com";
 Issue newIssue = new Issue(oldIssue.getExplanation(), newSeverity, oldIssue.getType(), newUrl);
 Set<String> issueColumns = ImmutableSet.of(col);
 Map<String, MajorIssueConfig> issueConfigs =
   ImmutableMap.of(
     major,
     new MajorIssueConfig(major, ImmutableList.of(new MinorIssueConfig(minor, 6, newUrl))));
 assertThat(
   _manager.applyRowIssuesConfiguration(oldRow, issueColumns, issueConfigs),
   equalTo(Row.of(col, newIssue)));
}

@Test
public void testComputeColumnMaxOneRowIssue() {
 String columnName = "col";
 int severity = 5;
 Issue value = new Issue("blah", severity, new Issue.Type("1", "2"));
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), equalTo(severity));
}

@Test
public void testColumnComparatorIssue() {
 String col = "col1";
 ColumnMetadata columnMetadata = new ColumnMetadata(col, Schema.ISSUE, "colDesc");
 Comparator<Row> comparator = _manager.columnComparator(columnMetadata);
 Row r1 = Row.of(col, new Issue("a", 1, new Issue.Type("major", "minor")));
 Row r2 = Row.of(col, new Issue("a", 2, new Issue.Type("major", "minor")));
 Row r3 = Row.of(col, new Issue("b", 1, new Issue.Type("major", "minor")));
 assertThat(comparator.compare(r1, r2), lessThan(0));
 assertThat(comparator.compare(r1, r3), equalTo(0));
 assertThat(comparator.compare(r2, r3), greaterThan(0));
}