How to use

org.batfish.datamodel.questions.DisplayHints

constructor

private DisplayHints getExtraction(String displayVariable) {
 DisplayHints displayHints = new DisplayHints();
 Map<String, Extraction> extractions = new HashMap<>();
 extractions.put(displayVariable, _displayHints.getExtractions().get(displayVariable));
 displayHints.setExtractions(extractions);
 return displayHints;
}

private DisplayHints getComposition(String displayVariable) {
 DisplayHints displayHints = new DisplayHints();
 Map<String, Composition> compositions = new HashMap<>();
 Composition composition = _displayHints.getCompositions().get(displayVariable);
 compositions.put(displayVariable, composition);
 displayHints.setCompositions(compositions);
 Map<String, Extraction> extractions = new HashMap<>();
 for (String varName : composition.getDictionary().values()) {
  extractions.put(varName, _displayHints.getExtractions().get(varName));
 }
 displayHints.setExtractions(extractions);
 return displayHints;
}

@Test
public void testComputeColumnMaxNoRows() {
 String columnName = "col";
 TableAnswerElement table =
   new TableAnswerElement(
     new TableMetadata(
       ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
       new DisplayHints().getTextDesc()));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), nullValue());
}

@Test
public void testComputeMajorIssueTypesNoColumn() {
 String columnName = "col";
 String value = "foo";
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.STRING, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 assertThat(AnswerMetadataUtil.computeMajorIssueConfigs(table), equalTo(ImmutableMap.of()));
}

@Test
public void testComputeColumnMaxNullInteger() {
 String columnName = "col";
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, null));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), nullValue());
}

@Test
public void testComputeColumnMaxInvalidSchema() {
 String columnName = "col";
 String value = "hello";
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.STRING, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), nullValue());
}

@Test
public void testComputeColumnMaxOneRowInteger() {
 String columnName = "col";
 int value = 5;
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), equalTo(value));
}

@Test
public void testComputeColumnAggregations() {
 String columnName = "col";
 int value = 5;
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 List<ColumnAggregation> aggregations =
   ImmutableList.of(new ColumnAggregation(Aggregation.MAX, columnName));
 assertThat(
   AnswerMetadataUtil.computeColumnAggregations(table, aggregations, _logger),
   equalTo(ImmutableMap.of(columnName, ImmutableMap.of(Aggregation.MAX, value))));
}

@Test
public void testComputeMajorIssueTypesNone() {
 String columnName = "col";
 TableMetadata tableMetadata =
   new TableMetadata(
     ImmutableList.of(new ColumnMetadata(columnName, Schema.ISSUE, "foobar")),
     new DisplayHints().getTextDesc());
 TableAnswerElement table =
   new TableAnswerElement(tableMetadata)
     .addRow(Row.builder(tableMetadata.toColumnMap()).build());
 assertThat(AnswerMetadataUtil.computeMajorIssueConfigs(table), equalTo(ImmutableMap.of()));
}

@Test
public void testComputeColumnMaxTwoRows() {
 String columnName = "col";
 int value1 = 5;
 int value2 = 10;
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value1))
     .addRow(Row.of(columnName, value2));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), equalTo(value2));
}

@Test
public void testComputeColumnMaxInvalidColumn() {
 String columnName = "col";
 String invalidColumnName = "invalid";
 int value = 5;
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value));
 _thrown.expect(IllegalArgumentException.class);
 AnswerMetadataUtil.computeColumnMax(table, invalidColumnName, _logger);
}

@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 testComputeColumnAggregationMax() {
 String columnName = "col";
 int value = 5;
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value))
     .addRow(Row.of(columnName, 2));
 ColumnAggregation columnAggregation = new ColumnAggregation(Aggregation.MAX, columnName);
 assertThat(
   AnswerMetadataUtil.computeColumnAggregation(table, columnAggregation, _logger),
   equalTo(new ColumnAggregationResult(Aggregation.MAX, columnName, value)));
}

 @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 testComputeColumnMaxNullAndNonNullInteger() {
 String columnName = "col";
 TableAnswerElement table =
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, 1))
     .addRow(Row.of(columnName, null))
     .addRow(Row.of(columnName, 3))
     .addRow(Row.of(columnName, null))
     .addRow(Row.of(columnName, 2));
 assertThat(AnswerMetadataUtil.computeColumnMax(table, columnName, _logger), equalTo(3));
}

@Test
public void testComputeAnswerMetadataInapplicable() throws IOException {
 String columnName = "col";
 List<Integer> value = ImmutableList.of(5);
 Answer testAnswer = new Answer();
 testAnswer.addAnswerElement(
   new TableAnswerElement(
       new TableMetadata(
         ImmutableList.of(
           new ColumnMetadata(columnName, Schema.list(Schema.INTEGER), "foobar")),
         new DisplayHints().getTextDesc()))
     .addRow(Row.of(columnName, value)));
 testAnswer.setStatus(AnswerStatus.SUCCESS);
 assertThat(
   AnswerMetadataUtil.computeAnswerMetadata(testAnswer, _logger),
   equalTo(
     AnswerMetadata.builder()
       .setMetrics(Metrics.builder().setNumRows(1).build())
       .setStatus(AnswerStatus.SUCCESS)
       .build()));
}

      new TableMetadata(
        ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
        new DisplayHints().getTextDesc()))
    .addRow(Row.of(columnName, value)));
String testAnswerStr = BatfishObjectMapper.writeString(testAnswer);

      new ColumnMetadata(columnName, Schema.INTEGER, "foobar"),
      new ColumnMetadata(issueColumnName, Schema.ISSUE, "barfoo")),
    new DisplayHints().getTextDesc()))
.addRow(Row.of(columnName, value, issueColumnName, issueValue))
.addExcludedRow(Row.of(columnName, excludedValue, issueColumnName, issueValue), "foo"));

      new TableMetadata(
        ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
        new DisplayHints().getTextDesc()))
    .addRow(Row.of(columnName, value)));
testAnswer.setStatus(AnswerStatus.SUCCESS);

      new TableMetadata(
        ImmutableList.of(new ColumnMetadata(columnName, Schema.INTEGER, "foobar")),
        new DisplayHints().getTextDesc()))
    .addRow(Row.of(columnName, value)));
testAnswer.setStatus(AnswerStatus.SUCCESS);