} else {
                return BYTE;
            }
        }
    }

    public String format(long size) {
        return format(size, null);
    }

    public String format(long size, ScaleUnit unit) {
        return format(size, unit, false);
    }

    public String format(long size, ScaleUnit unit, boolean omitSymbol) {
        StringBuilder sb = new StringBuilder();

    super(false, false, false, false);
  }

  @Override
  RowSortedTable<String, Integer, Character> makeTable() {
    RowSortedTable<String, Integer, Character> original = TreeBasedTable.create();
    return unmodifiableRowSortedTable(original);
  }

  @Override
  protected SortedMap<String, Map<Integer, Character>> makePopulatedMap() {
    RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("foo", 1, 'a');

    super(false, false, false, false);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    Table<String, Integer, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, Character> table = HashBasedTable.create();
    table.put("foo", 1, 'a');

    super(false, false, true, true, true);
  }

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    return transformValues(table, TableCollectionTest.DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    table.put('a', "one", 2);

                    "loc": {
                        "items": {"anyOf": [{"type": "string"}, {"type": "integer"}]},
                        "title": "Location",
                        "type": "array",
                    },
                    "msg": {"title": "Message", "type": "string"},
                    "type": {"title": "Error Type", "type": "string"},
                },
                "required": ["loc", "msg", "type"],

                        "msg": {
                            "title": "Message",
                            "type": "string",
                        },
                        "type": {
                            "title": "Error Type",
                            "type": "string",
                        },
                    },
                    "required": [
                        "loc",

            return (T) BooleanConversionUtil.toBoolean(arg);
        } else if (arg != null && arg.getClass() != String.class && String.class == propertyType) {
            return (T) arg.toString();
        } else if (arg instanceof String && !String.class.equals(propertyType)) {
            return (T) convertWithString(arg);
        } else if (java.util.Calendar.class.isAssignableFrom(propertyType)) {

    private static final long serialVersionUID = 1L;

    private OptionalEntity<CrawlingInfo> crawlingInfo;

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {
        return asDocMeta().version();
    }

    }

    public ProjectBuildingResultWithProblemMessageAssert hasProblemMessage(String problemMessage) {
        assertNotNull(actual);

        boolean hasMessage =
                actual.getProblems().stream().anyMatch(p -> p.getMessage().contains(problemMessage));

        if (!hasMessage) {
            String actualMessages = actual.getProblems().stream()
                    .map(ModelProblem::getMessage)

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {