Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: Validator { public static void ensureValidFieldName(String fieldName) { if (!validFieldName(fieldName)) { throw new ValidationException(String.format("Invalid field name: %s", fieldName)); } } Validator(); @SuppressWarnings("WeakerAccess") static boolean validIndexName(String indexName); static void ensureValidIndexName(String indexName); @SuppressWarnings("WeakerAccess") static boolean validFieldName(String fieldName); static void ensureValidFieldName(String fieldName); @SuppressWarnings("WeakerAccess") static boolean validLabel(String label); static void ensureValidLabel(String label); @SuppressWarnings("WeakerAccess") static boolean validKey(String key); static void ensureValidKey(String key); }### Answer: @Test public void ensureValidFieldNameTest() { String[] validFieldNames = new String[]{ "a", "ab", "ab1", "b-c", "d_e", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }; for (String name : validFieldNames) { Validator.ensureValidFieldName(name); } } @Test public void ensureValidFieldNameFailsTest() { String[] invalidFieldNames = new String[]{ "", "'", "^", "/", "\\", "A", "*", "a:b", "valid?no", "yüce", "_", "-", ".data", "d.e", "1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1" }; for (String name : invalidFieldNames) { try { Validator.ensureValidFieldName(name); } catch (ValidationException ex) { continue; } fail("Field name validation should have failed for: " + name); } }
### Question: Validator { public static void ensureValidLabel(String label) { if (!validLabel(label)) { throw new ValidationException(String.format("Invalid label: %s", label)); } } Validator(); @SuppressWarnings("WeakerAccess") static boolean validIndexName(String indexName); static void ensureValidIndexName(String indexName); @SuppressWarnings("WeakerAccess") static boolean validFieldName(String fieldName); static void ensureValidFieldName(String fieldName); @SuppressWarnings("WeakerAccess") static boolean validLabel(String label); static void ensureValidLabel(String label); @SuppressWarnings("WeakerAccess") static boolean validKey(String key); static void ensureValidKey(String key); }### Answer: @Test public void ensureValidLabelTest() { String[] validLabels = new String[]{ "a", "ab", "ab1", "d_e", "A", "Bc", "B1", "aB", "b-c", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }; for (String label : validLabels) { Validator.ensureValidLabel(label); } } @Test public void ensureValidLabelFailsTest() { String[] invalidLabels = new String[]{ "", "1", "_", "-", "'", "^", "/", "\\", "*", "a:b", "valid?no", "yüce", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1" }; for (String label : invalidLabels) { try { Validator.ensureValidLabel(label); } catch (ValidationException ex) { continue; } fail("Label validation should have failed for: " + label); } }
### Question: Validator { public static void ensureValidKey(String key) { if (!validKey(key)) { throw new ValidationException(String.format("Invalid key: %s", key)); } } Validator(); @SuppressWarnings("WeakerAccess") static boolean validIndexName(String indexName); static void ensureValidIndexName(String indexName); @SuppressWarnings("WeakerAccess") static boolean validFieldName(String fieldName); static void ensureValidFieldName(String fieldName); @SuppressWarnings("WeakerAccess") static boolean validLabel(String label); static void ensureValidLabel(String label); @SuppressWarnings("WeakerAccess") static boolean validKey(String key); static void ensureValidKey(String key); }### Answer: @Test public void ensureValidKeyTest() { String[] validKeys = new String[]{ "", "1", "ab", "ab1", "b-c", "d_e", "pilosa.com", "bbf8d41c-7dba-40c4-94dc-94677b43bcf3", "{bbf8d41c-7dba-40c4-94dc-94677b43bcf3}", "https%3A "aHR0cHM6Ly93d3cucGlsb3NhLmNvbS9hYm91dC8jY29udGFjdA==", "urn:isbn:1234567", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }; for (String key : validKeys) { Validator.ensureValidKey(key); } } @Test public void ensureValidKeyFailsTest() { String[] invalidKeys = new String[]{ "\"", "'", "slice\\dice", "valid?no", "yüce", "*xyz", "with space", "<script>", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1" }; for (String key : invalidKeys) { try { Validator.ensureValidKey(key); } catch (ValidationException ex) { continue; } fail("Key validation should have failed for: " + key); } }
### Question: ValueCountResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.value) .append(this.count) .toHashCode(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { ValueCountResult result1 = ValueCountResult.create(22, 7); ValueCountResult result2 = ValueCountResult.create(22, 7); assertEquals(result1.hashCode(), result2.hashCode()); }
### Question: GroupCountsResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof GroupCountsResult)) { return false; } GroupCountsResult rhs = (GroupCountsResult) obj; return this.items.equals(rhs.items); } private GroupCountsResult(final List<GroupCount> items); static GroupCountsResult create(final List<GroupCount> items); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { GroupCountsResult r1 = createSampleResult(); GroupCountsResult r2 = createSampleResult(); assertTrue(r1.equals(r1)); assertTrue(r1.equals(r2)); assertFalse(r1.equals(new Integer(10))); }
### Question: GroupCountsResult implements QueryResult { @Override public int hashCode() { return this.items.hashCode(); } private GroupCountsResult(final List<GroupCount> items); static GroupCountsResult create(final List<GroupCount> items); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { assertEquals(createSampleResult().hashCode(), createSampleResult().hashCode()); }
### Question: QueryResponse { void parseQueryResponse(Internal.QueryResponse response) { List<QueryResult> results = new ArrayList<>(response.getResultsCount()); for (Internal.QueryResult q : response.getResultsList()) { int type = q.getType(); switch (type) { case QueryResultType.ROW: results.add(RowResult.fromInternal(q)); break; case QueryResultType.BOOL: results.add(BoolResult.fromInternal(q)); break; case QueryResultType.INT: results.add(IntResult.fromInternal(q)); break; case QueryResultType.PAIRS: results.add(TopNResult.fromInternal(q)); break; case QueryResultType.VAL_COUNT: results.add(ValueCountResult.fromInternal(q)); break; case QueryResultType.NIL: results.add(NullResult.defaultResult()); break; case QueryResultType.GROUP_COUNTS: results.add(GroupCountsResult.fromInternal(q)); break; case QueryResultType.ROW_IDENTIFIERS: results.add(RowIdentifiersResult.fromInternal(q)); break; default: throw new PilosaException(String.format("Unknown type: %d", type)); } } this.results = results; ArrayList<ColumnItem> columns = new ArrayList<>(response.getColumnAttrSetsCount()); for (Internal.ColumnAttrSet column : response.getColumnAttrSetsList()) { columns.add(ColumnItem.fromInternal(column)); } this.columns = columns; } QueryResponse(); List<QueryResult> getResults(); QueryResult getResult(); List<ColumnItem> getColumns(); ColumnItem getColumn(); }### Answer: @Test(expected = PilosaException.class) public void testUnknownType() { Internal.QueryResult result = Internal.QueryResult.newBuilder() .setType(999) .build(); Internal.QueryResponse response = Internal.QueryResponse.newBuilder() .addResults(result) .build(); PilosaClient client = PilosaClient.defaultClient(); QueryResponse r = new QueryResponse(); r.parseQueryResponse(response); }
### Question: FieldValue implements Record { public static FieldValue create(long columnID, long value) { return create(columnID, "", value); } private FieldValue(); static FieldValue create(long columnID, long value); static FieldValue create(String columnKey, long value); long getColumnID(); String getColumnKey(); long getValue(); @Override long shard(long shardWidth); @Override boolean isDefault(); @Override int compareTo(Record record); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final FieldValue DEFAULT; }### Answer: @Test public void createTest() { FieldValue fieldValue; fieldValue = FieldValue.create(1, 100); compare(fieldValue, 1, "", 100); fieldValue = FieldValue.create("one", 100); compare(fieldValue, 0, "one", 100); } @Test public void equalsSameObjectTest() { FieldValue a = FieldValue.create(1, 100000); assertEquals(a, a); }
### Question: FieldValue implements Record { @Override public int hashCode() { if (this.defaultFieldValue) { return new HashCodeBuilder(31, 47).append(true).toHashCode(); } return new HashCodeBuilder(31, 47) .append(this.columnID) .append(this.columnKey) .append(this.value) .toHashCode(); } private FieldValue(); static FieldValue create(long columnID, long value); static FieldValue create(String columnKey, long value); long getColumnID(); String getColumnKey(); long getValue(); @Override long shard(long shardWidth); @Override boolean isDefault(); @Override int compareTo(Record record); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final FieldValue DEFAULT; }### Answer: @Test public void hashCodeTest() { FieldValue a = FieldValue.create(1, -100); FieldValue b = FieldValue.create(1, -100); assertEquals(a.hashCode(), b.hashCode()); assertNotEquals(a.hashCode(), FieldValue.DEFAULT.hashCode()); }
### Question: FieldValue implements Record { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof FieldValue)) { return false; } FieldValue other = (FieldValue) o; return this.defaultFieldValue == other.defaultFieldValue && this.columnID == other.columnID && this.columnKey.equals(other.columnKey) && this.value == other.value; } private FieldValue(); static FieldValue create(long columnID, long value); static FieldValue create(String columnKey, long value); long getColumnID(); String getColumnKey(); long getValue(); @Override long shard(long shardWidth); @Override boolean isDefault(); @Override int compareTo(Record record); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final FieldValue DEFAULT; }### Answer: @Test public void equalsTest() { FieldValue a = FieldValue.create(1, 100000); FieldValue b = FieldValue.create(1, 100000); assertEquals(a, b); FieldValue c = FieldValue.create("foo", 100); FieldValue d = FieldValue.create("foo", 100); assertEquals(c, d); assertNotEquals(a, c); }
### Question: FieldValue implements Record { @Override public String toString() { if (this.defaultFieldValue) { return "(default field value)"; } return String.format("%d %s = %d", this.columnID, this.columnKey, this.value); } private FieldValue(); static FieldValue create(long columnID, long value); static FieldValue create(String columnKey, long value); long getColumnID(); String getColumnKey(); long getValue(); @Override long shard(long shardWidth); @Override boolean isDefault(); @Override int compareTo(Record record); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final FieldValue DEFAULT; }### Answer: @Test public void toStringTest() { FieldValue a = FieldValue.create(15, 50000); assertEquals("15 = 50000", a.toString()); assertEquals("(default field value)", FieldValue.DEFAULT.toString()); }
### Question: FieldValue implements Record { @Override public int compareTo(Record record) { FieldValue fieldValue = (FieldValue) record; if (this.columnID == fieldValue.columnID) { return 0; } return (this.columnID < fieldValue.columnID) ? -1 : 1; } private FieldValue(); static FieldValue create(long columnID, long value); static FieldValue create(String columnKey, long value); long getColumnID(); String getColumnKey(); long getValue(); @Override long shard(long shardWidth); @Override boolean isDefault(); @Override int compareTo(Record record); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final FieldValue DEFAULT; }### Answer: @Test public void compareToTest() { FieldValue v1 = FieldValue.create(10, 5); FieldValue v2 = FieldValue.create(5, 7); FieldValue v3 = FieldValue.create(5, 3); List<FieldValue> fieldValueList = Arrays.asList(v1, v2, v3); Collections.sort(fieldValueList); assertEquals(fieldValueList.get(0), v2); assertEquals(fieldValueList.get(1), v3); assertEquals(fieldValueList.get(2), v1); }
### Question: CountResultItem { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CountResultItem)) { return false; } CountResultItem rhs = (CountResultItem) obj; return new EqualsBuilder() .append(this.id, rhs.id) .append(this.key, rhs.key) .append(this.count, rhs.count) .isEquals(); } long getID(); String getKey(); long getCount(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { CountResultItem result1 = createSampleResult(); CountResultItem result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
### Question: CountResultItem { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.id) .append(key) .append(this.count) .toHashCode(); } long getID(); String getKey(); long getCount(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { CountResultItem result1 = createSampleResult(); CountResultItem result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
### Question: URI { @SuppressWarnings("WeakerAccess") public static URI defaultURI() { return new URI(); } private URI(); @SuppressWarnings("WeakerAccess") static URI defaultURI(); @SuppressWarnings("WeakerAccess") static URI fromHostPort(String host, int port); static URI address(String address); @SuppressWarnings("WeakerAccess") String getScheme(); @SuppressWarnings("WeakerAccess") String getHost(); @SuppressWarnings("WeakerAccess") int getPort(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testDefault() { URI uri = URI.defaultURI(); compare(uri, "http", "localhost", 10101); }
### Question: URI { @SuppressWarnings("WeakerAccess") public static URI fromHostPort(String host, int port) { URI uri = new URI(); uri.setHost(host); uri.setPort(port); return uri; } private URI(); @SuppressWarnings("WeakerAccess") static URI defaultURI(); @SuppressWarnings("WeakerAccess") static URI fromHostPort(String host, int port); static URI address(String address); @SuppressWarnings("WeakerAccess") String getScheme(); @SuppressWarnings("WeakerAccess") String getHost(); @SuppressWarnings("WeakerAccess") int getPort(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHostPortAlternative() { URI uri = URI.fromHostPort("db1.pilosa.com", 3333); compare(uri, "http", "db1.pilosa.com", 3333); }
### Question: URI { @Override public String toString() { return String.format("%s: } private URI(); @SuppressWarnings("WeakerAccess") static URI defaultURI(); @SuppressWarnings("WeakerAccess") static URI fromHostPort(String host, int port); static URI address(String address); @SuppressWarnings("WeakerAccess") String getScheme(); @SuppressWarnings("WeakerAccess") String getHost(); @SuppressWarnings("WeakerAccess") int getPort(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testToString() { URI uri = URI.defaultURI(); assertEquals("http: }
### Question: URI { @Override public boolean equals(Object obj) { if (!(obj instanceof URI)) { return false; } if (obj == this) { return true; } URI rhs = (URI) obj; return (rhs.scheme.equals(this.scheme) && rhs.host.equals(this.host) && rhs.port == this.port); } private URI(); @SuppressWarnings("WeakerAccess") static URI defaultURI(); @SuppressWarnings("WeakerAccess") static URI fromHostPort(String host, int port); static URI address(String address); @SuppressWarnings("WeakerAccess") String getScheme(); @SuppressWarnings("WeakerAccess") String getHost(); @SuppressWarnings("WeakerAccess") int getPort(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { URI uri1 = URI.fromHostPort("pilosa.com", 1337); URI uri2 = URI.address("http: boolean e = uri1.equals(uri2); assertTrue(e); }
### Question: URI { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.scheme) .append(this.host) .append(this.port) .toHashCode(); } private URI(); @SuppressWarnings("WeakerAccess") static URI defaultURI(); @SuppressWarnings("WeakerAccess") static URI fromHostPort(String host, int port); static URI address(String address); @SuppressWarnings("WeakerAccess") String getScheme(); @SuppressWarnings("WeakerAccess") String getHost(); @SuppressWarnings("WeakerAccess") int getPort(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { URI uri1 = URI.defaultURI(); URI uri2 = URI.address("http: assertEquals(uri1.hashCode(), uri2.hashCode()); }
### Question: IntResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IntResult)) { return false; } return this.count == ((IntResult) obj).count; } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { IntResult result1 = IntResult.create(33); IntResult result2 = IntResult.create(33); boolean e = result1.equals(result2); assertTrue(e); } @Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new IntResult()).equals(0); assertFalse(e); }
### Question: Version { static Properties loadProperties(InputStream src) { Properties props = new Properties(); try { props.load(src); } catch (IOException e) { props.setProperty("version", "0.0.0"); props.setProperty("build.time", "2016-11-01 09:00:00"); } return props; } @SuppressWarnings("WeakerAccess") Version(); @SuppressWarnings("WeakerAccess") static String getVersion(); @SuppressWarnings("WeakerAccess") static String getBuildTime(); }### Answer: @Test public void testLoadPropertiesFailure() { InputStream inputStream = new InputStream() { @Override public int read() throws IOException { throw new IOException(); } }; Properties props = Version.loadProperties(inputStream); assertEquals("0.0.0", props.getProperty("version")); assertEquals("2016-11-01 09:00:00", props.getProperty("build.time")); }
### Question: FieldOptions { public static Builder builder() { return new Builder(); } private FieldOptions(final TimeQuantum timeQuantum, final CacheType cacheType, final Integer cacheSize, final FieldType fieldType, final long min, final long max, final Boolean keys); @SuppressWarnings("WeakerAccess") static FieldOptions withDefaults(); static FieldOptions fromMap(final Map<String, Object> map); static Builder builder(); TimeQuantum getTimeQuantum(); CacheType getCacheType(); int getCacheSize(); FieldType getFieldType(); long getMin(); long getMax(); boolean isKeys(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEqualsSameObject() { FieldOptions options = FieldOptions.builder().build(); assertEquals(options, options); }
### Question: FieldOptions { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.timeQuantum) .append(this.cacheType) .append(this.cacheSize) .append(this.fieldType) .append(this.min) .append(this.max) .append(this.keys) .toHashCode(); } private FieldOptions(final TimeQuantum timeQuantum, final CacheType cacheType, final Integer cacheSize, final FieldType fieldType, final long min, final long max, final Boolean keys); @SuppressWarnings("WeakerAccess") static FieldOptions withDefaults(); static FieldOptions fromMap(final Map<String, Object> map); static Builder builder(); TimeQuantum getTimeQuantum(); CacheType getCacheType(); int getCacheSize(); FieldType getFieldType(); long getMin(); long getMax(); boolean isKeys(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { FieldOptions options1, options2; options1 = FieldOptions.builder() .fieldSet(CacheType.RANKED, 100) .build(); options2 = FieldOptions.builder() .fieldSet(CacheType.RANKED, 100) .build(); assertEquals(options1.hashCode(), options2.hashCode()); options1 = FieldOptions.builder() .fieldInt(-100, 200) .build(); options2 = FieldOptions.builder() .fieldInt(-100, 200) .build(); assertEquals(options1.hashCode(), options2.hashCode()); options1 = FieldOptions.builder() .fieldTime(TimeQuantum.YEAR_MONTH) .build(); options2 = FieldOptions.builder() .fieldTime(TimeQuantum.YEAR_MONTH) .build(); assertEquals(options1.hashCode(), options2.hashCode()); }
### Question: Index { public static Index create(String name) { return create(name, IndexOptions.withDefaults()); } Index(Index index); private Index(String name, IndexOptions options); static Index create(String name); static Index create(String name, IndexOptions options); String getName(); Field field(String name); Field field(String name, FieldOptions options); Field field(String name, Map<String, Object> options); Field field(Field other); boolean hasField(String fieldName); PqlBatchQuery batchQuery(); @SuppressWarnings("WeakerAccess") PqlBatchQuery batchQuery(int queryCount); PqlBatchQuery batchQuery(PqlQuery... queries); PqlBaseQuery rawQuery(String query); @SuppressWarnings("WeakerAccess") PqlRowQuery union(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery intersect(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery difference(PqlRowQuery... rows); PqlRowQuery xor(PqlRowQuery... rows); PqlRowQuery not(PqlRowQuery row); PqlBaseQuery count(PqlRowQuery row); PqlBaseQuery setColumnAttrs(long id, Map<String, Object> attributes); PqlBaseQuery setColumnAttrs(String key, Map<String, Object> attributes); PqlBaseQuery options(PqlRowQuery row, OptionsOptions opts); PqlBaseQuery groupBy(PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowsQuery... queries); PqlBaseQuery groupBy(PqlRowQuery filterQuery, PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowQuery filterQuery, PqlRowsQuery... queries); Map<String, Field> getFields(); IndexOptions getOptions(); long getShardWidth(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test(expected = ValidationException.class) public void checkValidatorWasCalledTest() { Index.create("a:b"); }
### Question: Index { Index(Index index) { this(index.name, index.options); for (Map.Entry<String, Field> entry : index.fields.entrySet()) { this.field(entry.getKey(), entry.getValue().getOptions()); } } Index(Index index); private Index(String name, IndexOptions options); static Index create(String name); static Index create(String name, IndexOptions options); String getName(); Field field(String name); Field field(String name, FieldOptions options); Field field(String name, Map<String, Object> options); Field field(Field other); boolean hasField(String fieldName); PqlBatchQuery batchQuery(); @SuppressWarnings("WeakerAccess") PqlBatchQuery batchQuery(int queryCount); PqlBatchQuery batchQuery(PqlQuery... queries); PqlBaseQuery rawQuery(String query); @SuppressWarnings("WeakerAccess") PqlRowQuery union(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery intersect(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery difference(PqlRowQuery... rows); PqlRowQuery xor(PqlRowQuery... rows); PqlRowQuery not(PqlRowQuery row); PqlBaseQuery count(PqlRowQuery row); PqlBaseQuery setColumnAttrs(long id, Map<String, Object> attributes); PqlBaseQuery setColumnAttrs(String key, Map<String, Object> attributes); PqlBaseQuery options(PqlRowQuery row, OptionsOptions opts); PqlBaseQuery groupBy(PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowsQuery... queries); PqlBaseQuery groupBy(PqlRowQuery filterQuery, PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowQuery filterQuery, PqlRowsQuery... queries); Map<String, Field> getFields(); IndexOptions getOptions(); long getShardWidth(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEqualsSameObject() { Index index = this.schema.index("some-index"); assertEquals(index, index); }
### Question: Index { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.name) .toHashCode(); } Index(Index index); private Index(String name, IndexOptions options); static Index create(String name); static Index create(String name, IndexOptions options); String getName(); Field field(String name); Field field(String name, FieldOptions options); Field field(String name, Map<String, Object> options); Field field(Field other); boolean hasField(String fieldName); PqlBatchQuery batchQuery(); @SuppressWarnings("WeakerAccess") PqlBatchQuery batchQuery(int queryCount); PqlBatchQuery batchQuery(PqlQuery... queries); PqlBaseQuery rawQuery(String query); @SuppressWarnings("WeakerAccess") PqlRowQuery union(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery intersect(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery difference(PqlRowQuery... rows); PqlRowQuery xor(PqlRowQuery... rows); PqlRowQuery not(PqlRowQuery row); PqlBaseQuery count(PqlRowQuery row); PqlBaseQuery setColumnAttrs(long id, Map<String, Object> attributes); PqlBaseQuery setColumnAttrs(String key, Map<String, Object> attributes); PqlBaseQuery options(PqlRowQuery row, OptionsOptions opts); PqlBaseQuery groupBy(PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowsQuery... queries); PqlBaseQuery groupBy(PqlRowQuery filterQuery, PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowQuery filterQuery, PqlRowsQuery... queries); Map<String, Field> getFields(); IndexOptions getOptions(); long getShardWidth(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { Index index1 = this.schema.index("foo"); Index index2 = Index.create("foo"); assertEquals(index1.hashCode(), index2.hashCode()); }
### Question: Index { public boolean hasField(String fieldName) { return this.fields.containsKey(fieldName); } Index(Index index); private Index(String name, IndexOptions options); static Index create(String name); static Index create(String name, IndexOptions options); String getName(); Field field(String name); Field field(String name, FieldOptions options); Field field(String name, Map<String, Object> options); Field field(Field other); boolean hasField(String fieldName); PqlBatchQuery batchQuery(); @SuppressWarnings("WeakerAccess") PqlBatchQuery batchQuery(int queryCount); PqlBatchQuery batchQuery(PqlQuery... queries); PqlBaseQuery rawQuery(String query); @SuppressWarnings("WeakerAccess") PqlRowQuery union(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery intersect(PqlRowQuery... rows); @SuppressWarnings("WeakerAccess") PqlRowQuery difference(PqlRowQuery... rows); PqlRowQuery xor(PqlRowQuery... rows); PqlRowQuery not(PqlRowQuery row); PqlBaseQuery count(PqlRowQuery row); PqlBaseQuery setColumnAttrs(long id, Map<String, Object> attributes); PqlBaseQuery setColumnAttrs(String key, Map<String, Object> attributes); PqlBaseQuery options(PqlRowQuery row, OptionsOptions opts); PqlBaseQuery groupBy(PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowsQuery... queries); PqlBaseQuery groupBy(PqlRowQuery filterQuery, PqlRowsQuery... queries); PqlBaseQuery groupBy(Integer limit, PqlRowQuery filterQuery, PqlRowsQuery... queries); Map<String, Field> getFields(); IndexOptions getOptions(); long getShardWidth(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHasField() { Index index = this.schema.index("hasfield-index"); index.field("some-field"); assertTrue(index.hasField("some-field")); assertFalse(index.hasField("nonexistent-field")); }
### Question: Schema { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.indexes) .toHashCode(); } private Schema(); static Schema defaultSchema(); Index index(String name); Index index(String name, IndexOptions options); Index index(String name, IndexOptions options, long shardWidth); Index index(String name, Map<String, Object> options); Index index(Index other); boolean hasIndex(String indexName); Schema diff(Schema other); Map<String, Index> getIndexes(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { Schema schema1 = Schema.defaultSchema(); schema1.index("foo"); Schema schema2 = Schema.defaultSchema(); schema2.index("foo"); assertEquals(schema1.hashCode(), schema2.hashCode()); }
### Question: Schema { public boolean hasIndex(String indexName) { return this.indexes.containsKey(indexName); } private Schema(); static Schema defaultSchema(); Index index(String name); Index index(String name, IndexOptions options); Index index(String name, IndexOptions options, long shardWidth); Index index(String name, Map<String, Object> options); Index index(Index other); boolean hasIndex(String indexName); Schema diff(Schema other); Map<String, Index> getIndexes(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHasIndex() { Schema schema = Schema.defaultSchema(); schema.index("some-index"); assertTrue(schema.hasIndex("some-index")); assertFalse(schema.hasIndex("nonexistent-index")); }
### Question: IndexOptions { public static IndexOptions fromMap(final Map<String, Object> map) { Builder builder = builder(); for (Map.Entry<String, Object> entry : map.entrySet()) { switch (entry.getKey()) { case "keys": builder.setKeys((Boolean)(entry.getValue())); break; case "trackExistence": builder.setTrackExistence((Boolean)(entry.getValue())); break; default: throw new IllegalArgumentException(String.format("Unknown index option: '%s'", entry.getKey())); } } return builder.build(); } private IndexOptions(@JsonProperty("keys") final boolean keys, @JsonProperty("trackExistence") Boolean trackExistence); @SuppressWarnings("WeakerAccess") static IndexOptions withDefaults(); static IndexOptions fromMap(final Map<String, Object> map); static Builder builder(); boolean isKeys(); boolean isTrackExistence(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testFromMap() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("keys", true); optionsMap.put("trackExistence", false); IndexOptions options = IndexOptions.fromMap(optionsMap); assertTrue(options.isKeys()); assertFalse(options.isTrackExistence()); } @Test(expected = IllegalArgumentException.class) public void testFromMapInvalidKey() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("KEYS", true); IndexOptions options = IndexOptions.fromMap(optionsMap); } @Test(expected = ClassCastException.class) public void testFromMapInvalidKeysValue() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("keys", 1); IndexOptions options = IndexOptions.fromMap(optionsMap); } @Test(expected = ClassCastException.class) public void testFromMapInvalidTrackExistenceValue() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("trackExistence", 1); IndexOptions options = IndexOptions.fromMap(optionsMap); }
### Question: IntResult implements QueryResult { static IntResult create(long count) { IntResult result = new IntResult(); result.count = count; return result; } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEqualsSameObject() { IntResult result = IntResult.create(6); assertEquals(result, result); }
### Question: IndexOptions { public static Builder builder() { return new Builder(); } private IndexOptions(@JsonProperty("keys") final boolean keys, @JsonProperty("trackExistence") Boolean trackExistence); @SuppressWarnings("WeakerAccess") static IndexOptions withDefaults(); static IndexOptions fromMap(final Map<String, Object> map); static Builder builder(); boolean isKeys(); boolean isTrackExistence(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEqualsSameObject() { IndexOptions options = IndexOptions.builder().build(); assertEquals(options, options); }
### Question: IndexOptions { @Override public boolean equals(Object obj) { if (!(obj instanceof IndexOptions)) { return false; } if (obj == this) { return true; } IndexOptions rhs = (IndexOptions) obj; return rhs.keys == this.keys; } private IndexOptions(@JsonProperty("keys") final boolean keys, @JsonProperty("trackExistence") Boolean trackExistence); @SuppressWarnings("WeakerAccess") static IndexOptions withDefaults(); static IndexOptions fromMap(final Map<String, Object> map); static Builder builder(); boolean isKeys(); boolean isTrackExistence(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { IndexOptions options1, options2; options1 = IndexOptions.builder() .setKeys(true) .build(); options2 = IndexOptions.builder() .setKeys(true) .build(); assertEquals(options1, options2); }
### Question: IndexOptions { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.keys) .toHashCode(); } private IndexOptions(@JsonProperty("keys") final boolean keys, @JsonProperty("trackExistence") Boolean trackExistence); @SuppressWarnings("WeakerAccess") static IndexOptions withDefaults(); static IndexOptions fromMap(final Map<String, Object> map); static Builder builder(); boolean isKeys(); boolean isTrackExistence(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { IndexOptions options1, options2; options1 = IndexOptions.builder() .setKeys(true) .build(); options2 = IndexOptions.builder() .setKeys(true) .build(); assertEquals(options1.hashCode(), options2.hashCode()); }
### Question: RowResult implements QueryResult { @Override public String toString() { return String.format("RowResult(attrs=%s, columns=%s, keys=%s)", this.attributes, this.columns, this.keys); } Map<String, Object> getAttributes(); List<Long> getColumns(); List<String> getKeys(); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testRowResultToString() { RowResult result = createSampleResult(); String s = result.toString(); assertEquals("RowResult(attrs={color=blue}, columns=[42, 45], keys=[])", s); }
### Question: RowResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof RowResult)) { return false; } RowResult rhs = (RowResult) obj; return new EqualsBuilder() .append(this.attributes, rhs.attributes) .append(this.columns, rhs.columns) .append(this.keys, rhs.keys) .isEquals(); } Map<String, Object> getAttributes(); List<Long> getColumns(); List<String> getKeys(); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { RowResult result1 = createSampleResult(); RowResult result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
### Question: RowResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.attributes) .append(this.columns) .append(this.keys) .toHashCode(); } Map<String, Object> getAttributes(); List<Long> getColumns(); List<String> getKeys(); @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { RowResult result1 = createSampleResult(); RowResult result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
### Question: FieldRow { private FieldRow(String fieldName, long rowID, String rowKey) { this.fieldName = fieldName; this.rowID = rowID; this.rowKey = rowKey; } private FieldRow(String fieldName, long rowID, String rowKey); static FieldRow create(String fieldName, long rowID); static FieldRow create(String fieldName, String rowKey); String getFieldName(); long getRowID(); String getRowKey(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testFieldRow() { FieldRow f = FieldRow.create("f1", 42); assertEquals("f1", f.getFieldName()); assertEquals(42, f.getRowID()); assertEquals("", f.getRowKey()); assertEquals("FieldRow(field=f1, rowID=42, rowKey=)", f.toString()); f = FieldRow.create("f1", "forty-two"); assertEquals("f1", f.getFieldName()); assertEquals(0, f.getRowID()); assertEquals("forty-two", f.getRowKey()); assertEquals("FieldRow(field=f1, rowID=0, rowKey=forty-two)", f.toString()); }
### Question: IntResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.count) .toHashCode(); } @Override int getType(); @Override RowResult getRow(); @Override List<CountResultItem> getCountItems(); @Override long getCount(); @Override long getValue(); @Override boolean isChanged(); @Override List<GroupCount> getGroupCounts(); @Override RowIdentifiersResult getRowIdentifiers(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testHashCode() { IntResult result1 = IntResult.create(22); IntResult result2 = IntResult.create(22); assertEquals(result1.hashCode(), result2.hashCode()); }
### Question: HrrsUrlEncodedFormHelper { public boolean isUrlEncodedForm(String contentType) { if (contentType == null) { return false; } int semicolon = contentType.indexOf(';'); if (semicolon >= 0) { contentType = contentType.substring(0, semicolon).trim(); } else { contentType = contentType.trim(); } return "application/x-www-form-urlencoded".equals(contentType); } HrrsUrlEncodedFormHelper(); boolean isUrlEncodedForm(String contentType); HttpRequestPayload extractUrlEncodedFormPayload(HttpServletRequest request, String defaultEncoding); }### Answer: @Test public void test_isUrlEncodedForm() { String[] contentTypes = new String[] { "application/x-www-form-urlencoded", " application/x-www-form-urlencoded \r\n", "application/x-www-form-urlencoded; charset=utf-8", " application/x-www-form-urlencoded; charset=utf-8 " }; for (String contentType : contentTypes) { String message = String.format("content-type: %s", contentType); assertThat(message, urlEncodedFormHelper.isUrlEncodedForm(contentType), is(true)); } }
### Question: HrrsUrlEncodedFormHelper { public HttpRequestPayload extractUrlEncodedFormPayload(HttpServletRequest request, String defaultEncoding) { byte[] encodedFormParameterBytes = encodeFormParameters(request, defaultEncoding); return ImmutableHttpRequestPayload .newBuilder() .setMissingByteCount(0) .setBytes(encodedFormParameterBytes) .build(); } HrrsUrlEncodedFormHelper(); boolean isUrlEncodedForm(String contentType); HttpRequestPayload extractUrlEncodedFormPayload(HttpServletRequest request, String defaultEncoding); }### Answer: @Test public void test_extractUrlEncodedFormPayload() { HttpServletRequest request = mock(HttpServletRequest.class); String encoding = "ASCII"; when(request.getCharacterEncoding()).thenReturn(encoding); when(request.getQueryString()).thenReturn("y=y1"); when(request.getParameterNames()).thenReturn(Collections.enumeration(Arrays.asList("x", "y"))); when(request.getParameterValues("x")).thenReturn(new String[] {"x1", "x2"}); when(request.getParameterValues("y")).thenReturn(new String[] {"y2"}); HttpRequestPayload payload = urlEncodedFormHelper.extractUrlEncodedFormPayload(request, null); assertThat(payload.getMissingByteCount(), is(0)); assertThat(new String(payload.getBytes(), Charset.forName(encoding)), is(equalTo("x=x1&x=x2&y=y2"))); }
### Question: BitMapCharSet implements CharSet { @Override public boolean contains(char c) { return (c < mLength) && (mBitmap[c >>> 5] & (1 << (c & 0x1F))) != 0; } BitMapCharSet(int... bitmap); @Override boolean contains(char c); }### Answer: @Test public void testContains() throws Exception { assertFalse(new BitMapCharSet().contains(' ')); assertFalse(new BitMapCharSet(0).contains(' ')); assertFalse(new BitMapCharSet(0, 0).contains(' ')); assertFalse(new BitMapCharSet(0, 0, 0).contains(' ')); assertTrue(new BitMapCharSet(0, 1).contains(' ')); assertTrue(new BitMapCharSet(0, 1, 0).contains(' ')); assertTrue(new BitMapCharSet(0, 0x80000000).contains((char) 63)); assertTrue(new BitMapCharSet(0, 0x80000000, 0).contains((char) 63)); assertFalse(new BitMapCharSet(0, 0x80000000, 0).contains((char) 62)); assertFalse(new BitMapCharSet(0, 0x80000000, 0).contains((char) 64)); }
### Question: EncodedPath implements Path { @Override public boolean isEmpty() { return mPath.length() == 0; } EncodedPath(UriEncoded path); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void isEmpty() throws Exception { assertTrue(new EncodedPath(new Precoded("")).isEmpty()); assertFalse(new EncodedPath(new Precoded(".")).isEmpty()); assertFalse(new EncodedPath(new Precoded("abc")).isEmpty()); assertFalse(new EncodedPath(new Precoded("abc/123")).isEmpty()); }
### Question: EncodedPath implements Path { @Override public boolean isAbsolute() { return mPath.length() > 0 && mPath.charAt(0) == '/'; } EncodedPath(UriEncoded path); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void isAbsolute() throws Exception { assertFalse(new EncodedPath(new Precoded("")).isAbsolute()); assertFalse(new EncodedPath(new Precoded(".")).isAbsolute()); assertFalse(new EncodedPath(new Precoded("./")).isAbsolute()); assertFalse(new EncodedPath(new Precoded("abc")).isAbsolute()); assertFalse(new EncodedPath(new Precoded("abc/")).isAbsolute()); assertFalse(new EncodedPath(new Precoded("abc/123")).isAbsolute()); assertFalse(new EncodedPath(new Precoded("abc/123/")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/.")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/./")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/abc")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/abc/")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/abc/123")).isAbsolute()); assertTrue(new EncodedPath(new Precoded("/abc/123/")).isAbsolute()); }
### Question: EncodedPath implements Path { @Override public Iterator<UriEncoded> iterator() { if (isEmpty()) { return EmptyIterator.instance(); } return new ConvertedIterator<>(new Split(mPath, '/'), CONVERTER); } EncodedPath(UriEncoded path); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void iterator() throws Exception { }
### Question: EmptyPath implements Path { @Override public boolean isEmpty() { return true; } @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); final static EmptyPath INSTANCE; }### Answer: @Test public void isEmpty() throws Exception { assertTrue(new EmptyPath().isEmpty()); }
### Question: EmptyPath implements Path { @Override public boolean isAbsolute() { return false; } @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); final static EmptyPath INSTANCE; }### Answer: @Test public void isAbsolute() throws Exception { assertFalse(new EmptyPath().isAbsolute()); }
### Question: EmptyPath implements Path { @Override public Iterator<UriEncoded> iterator() { return EmptyIterator.instance(); } @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); @Override int hashCode(); @Override boolean equals(Object obj); final static EmptyPath INSTANCE; }### Answer: @Test public void iterator() throws Exception { assertFalse(new EmptyPath().iterator().hasNext()); }
### Question: StructuredPath implements Path { @Override public boolean isEmpty() { return mPathSegments.length == 0; } StructuredPath(UriEncoded... segments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsEmpty() throws Exception { assertTrue(new StructuredPath().isEmpty()); assertFalse(new StructuredPath(IdempotentEncoded.CURRENT).isEmpty()); assertFalse(new StructuredPath(new Encoded("abc")).isEmpty()); assertFalse(new StructuredPath(new Encoded("abc"), new Encoded("123")).isEmpty()); }
### Question: StructuredPath implements Path { @Override public boolean isAbsolute() { return mPathSegments.length > 0 && IdempotentEncoded.EMPTY.equals(mPathSegments[0]); } StructuredPath(UriEncoded... segments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsAbsolute() throws Exception { assertFalse(new StructuredPath().isAbsolute()); assertFalse(new StructuredPath(IdempotentEncoded.CURRENT).isAbsolute()); assertFalse(new StructuredPath(new Encoded("abc")).isAbsolute()); assertFalse(new StructuredPath(new Encoded("abc"), new Encoded("123")).isAbsolute()); }
### Question: StructuredPath implements Path { @Override public Iterator<UriEncoded> iterator() { return new ArrayIterator<>(mPathSegments); } StructuredPath(UriEncoded... segments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIterator() throws Exception { assertThat(new StructuredPath(), new IsEmptyIterable()); assertThat(new StructuredPath(IdempotentEncoded.EMPTY), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY)); assertThat(new StructuredPath(IdempotentEncoded.CURRENT), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT)); assertThat(new StructuredPath(IdempotentEncoded.PARENT), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT)); assertThat(new StructuredPath(IdempotentEncoded.PARENT, IdempotentEncoded.PARENT), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT)); assertThat(new StructuredPath(IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b")), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b"))); assertThat(new StructuredPath(IdempotentEncoded.CURRENT, new Encoded("a"), new Encoded("b")), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, new Encoded("a"), new Encoded("b"))); assertThat(new StructuredPath(IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b")), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b"))); }
### Question: Text implements CharSequence { @Override public int length() { if (mPath == null) { int len = 0; for (UriEncoded segment : mDelegate) { len += segment.length() + 1; } return len == 0 ? 0 : len - 1; } return mPath.length(); } Text(Path delegate); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int beginIndex, int endIndex); @Override String toString(); }### Answer: @Test public void testLength() throws Exception { assertEquals(0, new Text(new EncodedPath(new Precoded(""))).length()); assertEquals(1, new Text(new EncodedPath(new Precoded("/"))).length()); assertEquals(3, new Text(new EncodedPath(new Precoded("abc"))).length()); assertEquals(7, new Text(new EncodedPath(new Precoded("abc/def"))).length()); assertEquals(12, new Text(new EncodedPath(new Precoded("../abc/./def"))).length()); }
### Question: Text implements CharSequence { @Override public char charAt(int index) { return toString().charAt(index); } Text(Path delegate); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int beginIndex, int endIndex); @Override String toString(); }### Answer: @Test public void testCharAt() throws Exception { assertEquals('/', new Text(new EncodedPath(new Precoded("/"))).charAt(0)); assertEquals('a', new Text(new EncodedPath(new Precoded("abc"))).charAt(0)); assertEquals('b', new Text(new EncodedPath(new Precoded("abc"))).charAt(1)); assertEquals('c', new Text(new EncodedPath(new Precoded("abc"))).charAt(2)); assertEquals('a', new Text(new EncodedPath(new Precoded("abc/def"))).charAt(0)); assertEquals('/', new Text(new EncodedPath(new Precoded("abc/def"))).charAt(3)); assertEquals('f', new Text(new EncodedPath(new Precoded("abc/def"))).charAt(6)); assertEquals('.', new Text(new EncodedPath(new Precoded("../abc/./def"))).charAt(0)); assertEquals('/', new Text(new EncodedPath(new Precoded("../abc/./def"))).charAt(6)); assertEquals('f', new Text(new EncodedPath(new Precoded("../abc/./def"))).charAt(11)); }
### Question: Text implements CharSequence { @Override public CharSequence subSequence(int beginIndex, int endIndex) { return toString().subSequence(beginIndex, endIndex); } Text(Path delegate); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int beginIndex, int endIndex); @Override String toString(); }### Answer: @Test public void testSubSequence() throws Exception { assertEquals("", new Text(new EncodedPath(new Precoded(""))).subSequence(0, 0).toString()); assertEquals("/", new Text(new EncodedPath(new Precoded("/"))).subSequence(0, 1).toString()); assertEquals("b", new Text(new EncodedPath(new Precoded("abc"))).subSequence(1, 2).toString()); assertEquals("c/d", new Text(new EncodedPath(new Precoded("abc/def"))).subSequence(2, 5).toString()); assertEquals("bc/./d", new Text(new EncodedPath(new Precoded("../abc/./def"))).subSequence(4, 10).toString()); }
### Question: Text implements CharSequence { @Override public String toString() { if (mPath == null) { StringBuilder stringBuilder = new StringBuilder(256); boolean first = true; for (UriEncoded segment : mDelegate) { if (first) { first = false; } else { stringBuilder.append('/'); } stringBuilder.append(segment); } mPath = stringBuilder.toString(); } return mPath; } Text(Path delegate); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int beginIndex, int endIndex); @Override String toString(); }### Answer: @Test public void testToString() throws Exception { assertEquals("", new Text(new EncodedPath(new Precoded(""))).toString()); assertEquals("/", new Text(new EncodedPath(new Precoded("/"))).toString()); assertEquals("abc", new Text(new EncodedPath(new Precoded("abc"))).toString()); assertEquals("abc/def", new Text(new EncodedPath(new Precoded("abc/def"))).toString()); assertEquals("../abc/./def", new Text(new EncodedPath(new Precoded("../abc/./def"))).toString()); }
### Question: Extended implements Path { @Override public boolean isEmpty() { return mDelegate.isEmpty() && !mNewSegments.iterator().hasNext(); } Extended(Path delegate, UriEncoded... newSegments); Extended(Path delegate, Path newSegments); private Extended(Path delegate, Iterable<UriEncoded> newSegments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void isEmpty() throws Exception { assertTrue(new Extended(EmptyPath.INSTANCE, EmptyPath.INSTANCE).isEmpty()); assertFalse(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("abc/def"))).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("abc/def")), EmptyPath.INSTANCE).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("abc/def")), new EncodedPath(new Precoded("123"))).isEmpty()); assertFalse(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/abc"))).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("/abc")), EmptyPath.INSTANCE).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("/def"))).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("abc")), new EncodedPath(new Precoded("/def"))).isEmpty()); assertFalse(new Extended(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("def"))).isEmpty()); }
### Question: Extended implements Path { @Override public boolean isAbsolute() { return mDelegate.isAbsolute(); } Extended(Path delegate, UriEncoded... newSegments); Extended(Path delegate, Path newSegments); private Extended(Path delegate, Iterable<UriEncoded> newSegments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void isAbsolute() throws Exception { assertFalse(new Extended(EmptyPath.INSTANCE, EmptyPath.INSTANCE).isAbsolute()); assertFalse(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("abc/def"))).isAbsolute()); assertFalse(new Extended(new EncodedPath(new Precoded("abc/def")), EmptyPath.INSTANCE).isAbsolute()); assertFalse(new Extended(new EncodedPath(new Precoded("abc/def")), new EncodedPath(new Precoded("123"))).isAbsolute()); assertFalse(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/abc"))).isAbsolute()); assertFalse(new Extended(new EncodedPath(new Precoded("abc")), new EncodedPath(new Precoded("/def"))).isAbsolute()); assertTrue(new Extended(new EncodedPath(new Precoded("/abc")), EmptyPath.INSTANCE).isAbsolute()); assertTrue(new Extended(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("/def"))).isAbsolute()); assertTrue(new Extended(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("def"))).isAbsolute()); }
### Question: Normalized implements Path { @Override public boolean isEmpty() { return mDelegate.isEmpty(); } Normalized(Path delegate); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsEmpty() throws Exception { assertTrue(new Normalized(new EncodedPath(new Precoded(""))).isEmpty()); assertFalse(new Normalized(new EncodedPath(new Precoded("/"))).isEmpty()); }
### Question: Normalized implements Path { @Override public boolean isAbsolute() { return mDelegate.isAbsolute(); } Normalized(Path delegate); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsAbsolute() throws Exception { assertFalse(new Normalized(new EncodedPath(new Precoded("abc"))).isAbsolute()); assertTrue(new Normalized(new EncodedPath(new Precoded("/"))).isAbsolute()); }
### Question: Resolved implements Path { @Override public boolean isEmpty() { return mBase.isEmpty() && mReference.isEmpty(); } Resolved(Path base, Path reference); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsEmpty() throws Exception { assertTrue(new Resolved(EmptyPath.INSTANCE, EmptyPath.INSTANCE).isEmpty()); assertFalse(new Resolved(EmptyPath.INSTANCE, new EncodedPath(new Precoded("abc/def"))).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("abc/def")), EmptyPath.INSTANCE).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("abc/def")), new EncodedPath(new Precoded("123"))).isEmpty()); assertFalse(new Resolved(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/abc"))).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("/abc")), EmptyPath.INSTANCE).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("/def"))).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("abc")), new EncodedPath(new Precoded("/def"))).isEmpty()); assertFalse(new Resolved(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("def"))).isEmpty()); }
### Question: Resolved implements Path { @Override public boolean isAbsolute() { return mBase.isAbsolute() \|\| mReference.isAbsolute(); } Resolved(Path base, Path reference); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }### Answer: @Test public void testIsAbsolute() throws Exception { assertFalse(new Resolved(EmptyPath.INSTANCE, EmptyPath.INSTANCE).isAbsolute()); assertFalse(new Resolved(EmptyPath.INSTANCE, new EncodedPath(new Precoded("abc/def"))).isAbsolute()); assertFalse(new Resolved(new EncodedPath(new Precoded("abc/def")), EmptyPath.INSTANCE).isAbsolute()); assertFalse(new Resolved(new EncodedPath(new Precoded("abc/def")), new EncodedPath(new Precoded("123"))).isAbsolute()); assertTrue(new Resolved(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/abc"))).isAbsolute()); assertTrue(new Resolved(new EncodedPath(new Precoded("/abc")), EmptyPath.INSTANCE).isAbsolute()); assertTrue(new Resolved(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("/def"))).isAbsolute()); assertTrue(new Resolved(new EncodedPath(new Precoded("abc")), new EncodedPath(new Precoded("/def"))).isAbsolute()); assertTrue(new Resolved(new EncodedPath(new Precoded("/abc")), new EncodedPath(new Precoded("def"))).isAbsolute()); }
### Question: LazyUri implements Uri { @Override public Optional<? extends Scheme> scheme() { return mOptionalScheme; } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void scheme() throws Exception { assertEquals("http", new LazyUri(new Precoded("http: assertEquals("http", new LazyUri(new Precoded("http: assertEquals("http", new LazyUri(new Precoded("http: assertEquals("http", new LazyUri(new Precoded("http: assertEquals("urn", new LazyUri(new Precoded("urn:isbn:3827370191")).scheme().value().toString()); assertEquals("file", new LazyUri(new Precoded("file: assertEquals("mailto", new LazyUri(new Precoded("mailto:[email protected]")).scheme().value().toString()); assertFalse(new LazyUri(new Precoded(" assertFalse(new LazyUri(new Precoded("/absolute/path")).scheme().isPresent()); assertFalse(new LazyUri(new Precoded("relative/path")).scheme().isPresent()); assertFalse(new LazyUri(new Precoded("?q=:query:")).scheme().isPresent()); }
### Question: LazyUri implements Uri { @Override public OptionalLazyAuthority authority() { if (mAuthority == null) { mAuthority = new OptionalLazyAuthority(mUriEncoded.subSequence(mOptionalScheme.parsedLength(), mUriEncoded.length())); } return mAuthority; } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void authority() throws Exception { assertEquals("example.com", new LazyUri(new Precoded("http: assertEquals("example.com", new LazyUri(new Precoded("http: assertEquals("example.com", new LazyUri(new Precoded("http: assertEquals("example.com", new LazyUri(new Precoded("http: assertEquals("example.com", new LazyUri(new Precoded(" assertEquals("", new LazyUri(new Precoded("file: assertFalse(new LazyUri(new Precoded("mailto:[email protected]")).authority().isPresent()); assertFalse(new LazyUri(new Precoded("urn:isbn:3827370191")).authority().isPresent()); }
### Question: LazyUri implements Uri { @Override public LazyPath path() { if (mPath == null) { mPath = new LazyPath(mUriEncoded.subSequence(mOptionalScheme.parsedLength() + authority().parsedLength(), mUriEncoded.length())); } return mPath; } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void testPath() throws Exception { assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertEquals("/", new Text(new LazyUri(new Precoded("http: assertEquals("/test/123", new Text(new LazyUri(new Precoded("http: assertEquals("/", new Text(new LazyUri(new Precoded("http: assertEquals("/test/123", new Text(new LazyUri(new Precoded("http: assertEquals("[email protected]", new Text(new LazyUri(new Precoded("mailto:[email protected]")).path()).toString()); assertEquals("/test/123", new Text(new LazyUri(new Precoded("file: }
### Question: LazyUri implements Uri { @Override public OptionalLazyQuery query() { if (mQuery == null) { mQuery = new OptionalLazyQuery( mUriEncoded.subSequence(mOptionalScheme.parsedLength() + authority().parsedLength() + path().parsedLength(), mUriEncoded.length())); } return mQuery; } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void query() throws Exception { assertFalse(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertEquals("", new LazyUri(new Precoded("http: assertEquals("q=test", new LazyUri(new Precoded("http: }
### Question: LazyUri implements Uri { @Override public Optional<? extends Fragment> fragment() { if (mFragment == null) { mFragment = new OptionalLazyFragment( mUriEncoded.subSequence(mOptionalScheme.parsedLength() + authority().parsedLength() + path().parsedLength() + query().parsedLength(), mUriEncoded.length())); } return mFragment; } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void fragment() throws Exception { assertFalse(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertTrue(new LazyUri(new Precoded("http: assertEquals("", new LazyUri(new Precoded("http: assertEquals("q=test", new LazyUri(new Precoded("http: }
### Question: LazyUri implements Uri { @Override public boolean isHierarchical() { return !mOptionalScheme.isPresent() \|\| authority().isPresent() \|\| path().isAbsolute(); } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void isHierarchical() throws Exception { assertFalse(new LazyUri(new Precoded("mailto:[email protected]")).isHierarchical()); assertTrue(new LazyUri(new Precoded("http: }
### Question: LazyUri implements Uri { @Override public boolean isAbsolute() { return mOptionalScheme.isPresent(); } LazyUri(UriEncoded uri); @Override Optional<? extends Scheme> scheme(); @Override OptionalLazyAuthority authority(); @Override LazyPath path(); @Override OptionalLazyQuery query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); }### Answer: @Test public void isAbsolute() throws Exception { assertFalse(new LazyUri(new Precoded("/some/path")).isAbsolute()); assertTrue(new LazyUri(new Precoded("http: }
### Question: Text implements CharSequence { @Override public String toString() { if (mString == null) { StringBuilder stringBuilder = new StringBuilder(128); if (mUri.scheme().isPresent()) { stringBuilder.append(mUri.scheme().value().toString()); stringBuilder.append(':'); } Optional<? extends Authority> optAuthority = mUri.authority(); if (optAuthority.isPresent()) { stringBuilder.append('/'); stringBuilder.append('/'); stringBuilder.append(new org.dmfs.rfc3986.authorities.Text(optAuthority.value())); } stringBuilder.append(new org.dmfs.rfc3986.paths.Text(mUri.path())); Optional<? extends Query> optQuery = mUri.query(); if (optQuery.isPresent()) { stringBuilder.append('?'); stringBuilder.append(optQuery.value()); } Optional<? extends Fragment> optFragment = mUri.fragment(); if (optFragment.isPresent()) { stringBuilder.append('#'); stringBuilder.append(optFragment.value()); } mString = stringBuilder.toString(); } return mString; } Text(Uri uri); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }### Answer: @Test public void testToString() throws Exception { assertEquals("http: new StructuredUri(new StringScheme("http"), new EncodedAuthority(new Precoded("example.com")), new EncodedPath(new Precoded("/test")), new SimpleQuery(new Precoded("x=y")), new SimpleFragment(new Precoded("123")))).toString()); assertEquals("http: new StructuredUri(new StringScheme("http"), new EncodedAuthority(new Precoded("example.com")), new EncodedPath(new Precoded("/test")), new SimpleQuery(new Precoded("x=y")))).toString()); assertEquals("/test?x=y", new Text( new RelativeUri(new EncodedPath(new Precoded("/test")), new SimpleQuery(new Precoded("x=y")))).toString()); }
### Question: EmptyUri implements Uri { @Override public Optional<? extends Scheme> scheme() { return absent(); } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testScheme() throws Exception { assertFalse(new EmptyUri().scheme().isPresent()); }
### Question: EmptyUri implements Uri { @Override public Optional<? extends Authority> authority() { return absent(); } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testAuthority() throws Exception { assertFalse(new EmptyUri().authority().isPresent()); }
### Question: EmptyUri implements Uri { @Override public Path path() { return EmptyPath.INSTANCE; } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testPath() throws Exception { assertTrue(new EmptyUri().path().isEmpty()); }
### Question: EmptyUri implements Uri { @Override public Optional<? extends Query> query() { return absent(); } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testQuery() throws Exception { assertFalse(new EmptyUri().query().isPresent()); }
### Question: EmptyUri implements Uri { @Override public Optional<? extends Fragment> fragment() { return absent(); } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testFragment() throws Exception { assertFalse(new EmptyUri().fragment().isPresent()); }
### Question: EmptyUri implements Uri { @Override public boolean isHierarchical() { return false; } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testIsHierarchical() throws Exception { assertFalse(new EmptyUri().isHierarchical()); }
### Question: EmptyUri implements Uri { @Override public boolean isAbsolute() { return false; } @Override Optional<? extends Scheme> scheme(); @Override Optional<? extends Authority> authority(); @Override Path path(); @Override Optional<? extends Query> query(); @Override Optional<? extends Fragment> fragment(); @Override boolean isHierarchical(); @Override boolean isAbsolute(); final static EmptyUri INSTANCE; }### Answer: @Test public void testIsAbsolute() throws Exception { assertFalse(new EmptyUri().isAbsolute()); }
### Question: Text implements UriEncoded { @Override public char charAt(int i) { return toString().charAt(i); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }### Answer: @Ignore @Test public void testCharAt() throws Exception { }
### Question: Text implements UriEncoded { @Override public UriEncoded subSequence(int startIndex, int endIndex) { if (startIndex == 0 && endIndex == toString().length()) { return this; } return new Precoded(toString().subSequence(startIndex, endIndex)); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }### Answer: @Ignore @Test public void testSubSequence() throws Exception { }
### Question: Text implements UriEncoded { @Override public String toString() { if (mText == null) { StringBuilder builder = new StringBuilder(64); Optional<? extends UriEncoded> mUserInfo = mDelegate.userInfo(); if (mUserInfo.isPresent()) { builder.append(mUserInfo.value().normalized()); builder.append('@'); } builder.append(mDelegate.host().normalized()); Optional<Integer> port = mDelegate.port(); if (port.isPresent()) { builder.append(':'); builder.append((int) port.value()); } mText = builder.toString(); } return mText; } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }### Answer: @Ignore @Test public void testToString() throws Exception { }
### Question: Text implements UriEncoded { @Override public UriEncoded normalized() { return this; } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }### Answer: @Test public void testNormalized() throws Exception { assertEquals("user@host:123", new Text(new StructuredAuthority(new Precoded("user"), new Precoded("host"), 123)).normalized().toString()); assertEquals("user%40host@host:123", new Text(new StructuredAuthority(new Precoded("%75%73%65%72%40%68%6F%73%74"), new Precoded("%68%6F%73%74"), 123)).normalized().toString()); }
### Question: Text implements UriEncoded { @Override public CharSequence decoded(String charset) throws UnsupportedEncodingException { throw new UnsupportedOperationException("an Authority can't be decoded as a whole"); } Text(Authority delegate); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override String toString(); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); }### Answer: @Ignore @Test public void testDecoded() throws Exception { }
### Question: OptionalLazyAuthority implements Optional<Authority>, Parsed { @Override public boolean isPresent() { return authority().isPresent(); } OptionalLazyAuthority(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Authority value(Authority defaultValue); @Override Authority value(); @Override int parsedLength(); }### Answer: @Test public void testIsPresent() throws Exception { assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertTrue(new OptionalLazyAuthority(new Precoded(" assertFalse(new OptionalLazyAuthority(new Precoded("")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("/")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("test")).isPresent()); assertFalse(new OptionalLazyAuthority(new Precoded("about:")).isPresent()); }
### Question: StringScheme implements Scheme { @Override public int length() { return mScheme.length(); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }### Answer: @Test public void testLength() throws Exception { assertEquals(4, new StringScheme("http").length()); } @Test(expected = IllegalArgumentException.class) public void testLengthIllegalChar() throws Exception { new StringScheme("http_").length(); }
### Question: Precoded implements UriEncoded { @Override public int length() { return mEnd - mStart; } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void length() throws Exception { }
### Question: StringScheme implements Scheme { @Override public char charAt(int i) { return mScheme.charAt(i); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }### Answer: @Test public void testCharAt() throws Exception { assertEquals('h', new StringScheme("http").charAt(0)); assertEquals('t', new StringScheme("http").charAt(1)); assertEquals('t', new StringScheme("http").charAt(2)); assertEquals('p', new StringScheme("http").charAt(3)); } @Test(expected = IllegalArgumentException.class) public void testCharAtIllegalChar() throws Exception { new StringScheme("http_").charAt(0); }
### Question: StringScheme implements Scheme { @Override public CharSequence subSequence(int i, int i1) { return mScheme.subSequence(i, i1); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }### Answer: @Test public void testSubSequence() throws Exception { assertEquals("tt", new StringScheme("http").subSequence(1, 3).toString()); } @Test(expected = IllegalArgumentException.class) public void testSubSequenceIllegalChar() throws Exception { new StringScheme("http_").subSequence(1, 2); }
### Question: StringScheme implements Scheme { @Override public String toString() { return mScheme.toString(); } StringScheme(String scheme); @Override int length(); @Override char charAt(int i); @Override CharSequence subSequence(int i, int i1); @Override String toString(); }### Answer: @Test public void testToString() throws Exception { assertEquals("http", new StringScheme("http").toString()); } @Test(expected = IllegalArgumentException.class) public void testToStringIllegalChar() throws Exception { new StringScheme("http_").toString(); }
### Question: OptionalLazyScheme implements Optional<Scheme>, Parsed { @Override public boolean isPresent() { return scheme().isPresent(); } OptionalLazyScheme(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Scheme value(Scheme defaultValue); @Override Scheme value(); @Override int parsedLength(); }### Answer: @Test public void isPresent() throws Exception { assertTrue(new OptionalLazyScheme(new Precoded("http: assertTrue(new OptionalLazyScheme(new Precoded("http: assertTrue(new OptionalLazyScheme(new Precoded("mailto:[email protected]")).isPresent()); assertTrue(new OptionalLazyScheme(new Precoded("example.com:123")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded(" assertFalse(new OptionalLazyScheme(new Precoded("")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded(":")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded("123abc:")).isPresent()); assertFalse(new OptionalLazyScheme(new Precoded("[email protected]:123")).isPresent()); }
### Question: OptionalLazyScheme implements Optional<Scheme>, Parsed { @Override public Scheme value(Scheme defaultValue) { return scheme().value(defaultValue); } OptionalLazyScheme(UriEncoded uriEncoded); @Override boolean isPresent(); @Override Scheme value(Scheme defaultValue); @Override Scheme value(); @Override int parsedLength(); }### Answer: @Test public void value() throws Exception { assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("mailto", new OptionalLazyScheme(new Precoded("mailto:[email protected]")).value().toString()); assertEquals("example.com", new OptionalLazyScheme(new Precoded("example.com:123")).value().toString()); } @Test(expected = NoSuchElementException.class) public void valueFail1() throws Exception { new OptionalLazyScheme(new Precoded(" } @Test(expected = NoSuchElementException.class) public void valueFail2() throws Exception { new OptionalLazyScheme(new Precoded("")).value(); } @Test(expected = NoSuchElementException.class) public void valueFail3() throws Exception { new OptionalLazyScheme(new Precoded("[email protected]:123")).value(); } @Test public void valueWithDefault() throws Exception { assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("http", new OptionalLazyScheme(new Precoded("http: assertEquals("mailto", new OptionalLazyScheme(new Precoded("mailto:[email protected]")).value(new StringScheme("default")).toString()); assertEquals("example.com", new OptionalLazyScheme(new Precoded("example.com:123")).value(new StringScheme("default")).toString()); assertEquals("default", new OptionalLazyScheme(new Precoded(" assertEquals("default", new OptionalLazyScheme(new Precoded("")).value(new StringScheme("default")).toString()); assertEquals("default", new OptionalLazyScheme(new Precoded("[email protected]:123")).value(new StringScheme("default")).toString()); }
### Question: Precoded implements UriEncoded { @Override public char charAt(int i) { if (i < 0) { throw new ArrayIndexOutOfBoundsException(String.format("Index %d is negative.", i)); } if (mStart + i >= mEnd) { throw new ArrayIndexOutOfBoundsException(String.format("Index %d exceeds length %d", i, length())); } return mEncoded.charAt(i + mStart); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void charAt() throws Exception { }
### Question: Schemes { private Schemes() { } private Schemes(); final static Scheme FTP; final static Scheme HTTP; final static Scheme HTTPS; final static Scheme MAILTO; }### Answer: @Test public void testSchemes() { assertEquals("ftp", Schemes.FTP.toString()); assertEquals("http", Schemes.HTTP.toString()); assertEquals("https", Schemes.HTTPS.toString()); assertEquals("mailto", Schemes.MAILTO.toString()); }
### Question: TextValueType implements ValueType<CharSequence> { @Override public CharSequence parsedValue(CharSequence valueText) { return valueText; } @Override CharSequence parsedValue(CharSequence valueText); @Override CharSequence serializedValue(CharSequence value); final static TextValueType INSTANCE; }### Answer: @Test public void testParsedValue() throws Exception { assertEquals("", TextValueType.INSTANCE.parsedValue("")); assertEquals("abc", TextValueType.INSTANCE.parsedValue("abc")); }
### Question: TextValueType implements ValueType<CharSequence> { @Override public CharSequence serializedValue(CharSequence value) { return value; } @Override CharSequence parsedValue(CharSequence valueText); @Override CharSequence serializedValue(CharSequence value); final static TextValueType INSTANCE; }### Answer: @Test public void testSerializedValue() throws Exception { assertEquals("", TextValueType.INSTANCE.serializedValue("")); assertEquals("abc", TextValueType.INSTANCE.serializedValue("abc")); }
### Question: UrlEncodedParameter implements Parameter { @Override public CharSequence name() { parse(); try { return mName.decoded(mCharSet); } catch (UnsupportedEncodingException e) { throw new RuntimeException(String.format("CharSet %s not supported by Runtime", mCharSet)); } } UrlEncodedParameter(UriEncoded encodedPair); UrlEncodedParameter(UriEncoded encodedParameter, String charSet); @Override CharSequence name(); @Override CharSequence textValue(); }### Answer: @Test public void name() throws Exception { assertEquals("test", new UrlEncodedParameter(new Precoded("test")).name().toString()); assertEquals("testa", new UrlEncodedParameter(new Precoded("test%61")).name().toString()); assertEquals("test=", new UrlEncodedParameter(new Precoded("test%3D")).name().toString()); assertEquals("test", new UrlEncodedParameter(new Precoded("test=123")).name().toString()); assertEquals("testa", new UrlEncodedParameter(new Precoded("test%61=123%34")).name().toString()); assertEquals("test=", new UrlEncodedParameter(new Precoded("test%3D=123%3D")).name().toString()); }
### Question: UrlEncodedParameter implements Parameter { @Override public CharSequence textValue() { parse(); try { return mValue.decoded(mCharSet); } catch (UnsupportedEncodingException e) { throw new RuntimeException(String.format("CharSet %s not supported by Runtime", mCharSet)); } } UrlEncodedParameter(UriEncoded encodedPair); UrlEncodedParameter(UriEncoded encodedParameter, String charSet); @Override CharSequence name(); @Override CharSequence textValue(); }### Answer: @Test public void textValue() throws Exception { assertEquals("", new UrlEncodedParameter(new Precoded("test")).textValue().toString()); assertEquals("", new UrlEncodedParameter(new Precoded("test%61")).textValue().toString()); assertEquals("", new UrlEncodedParameter(new Precoded("test%3D")).textValue().toString()); assertEquals("123", new UrlEncodedParameter(new Precoded("test=123")).textValue().toString()); assertEquals("1234", new UrlEncodedParameter(new Precoded("test%61=123%34")).textValue().toString()); assertEquals("123=", new UrlEncodedParameter(new Precoded("test%3D=123%3D")).textValue().toString()); }
### Question: Precoded implements UriEncoded { @Override public UriEncoded subSequence(int startIndex, int endIndex) { if (startIndex == 0 && endIndex == length()) { return this; } if (endIndex < startIndex) { throw new ArrayIndexOutOfBoundsException(String.format("Start index %d < end index %d.", startIndex, endIndex)); } if (startIndex < 0) { throw new ArrayIndexOutOfBoundsException(String.format("Start index %d is negative.", startIndex)); } if (mStart + endIndex > mEnd) { throw new ArrayIndexOutOfBoundsException(String.format("End index %d exceeds length %d", endIndex, length())); } return new Precoded(mEncoded, startIndex + mStart, endIndex + mStart); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void subSequence() throws Exception { assertEquals(new Precoded("123"), new Precoded("abc123xyz").subSequence(3, 6)); assertEquals("123", new Precoded("abc123xyz").subSequence(3, 6).toString()); }
### Question: Precoded implements UriEncoded { @Override public int hashCode() { return normalized().hashCode(); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testHashCode() throws Exception { }
### Question: Precoded implements UriEncoded { @Override public boolean equals(Object obj) { return obj instanceof UriEncoded && normalized().equals(obj); } Precoded(CharSequence encoded); private Precoded(CharSequence encoded, int start, int end); @Override UriEncoded normalized(); @Override CharSequence decoded(String charset); @Override CharSequence decoded(); @Override int length(); @Override char charAt(int i); @Override UriEncoded subSequence(int startIndex, int endIndex); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void equals() throws Exception { }
### Question: ToggleJsonNode { public static JsonNode fromString(String json) { try { return DEFAULT_OBJECT_READER.readTree(json); } catch (IOException err) { return MissingNode.getInstance(); } } static JsonNode fromString(String json); static JsonNode findByKey(Iterator<JsonNode> iterator, String key); static boolean matchesCohort(JsonNode node, Optional<String> cohortOpt); static JsonNode findByCohort(JsonNode node, Optional<String> cohortOpt); static final ObjectReader DEFAULT_OBJECT_READER; }### Answer: @Test public void producesJsonNodeFromString() { final JsonNode node = ToggleJsonNode.fromString("{\"foo\": 4, \"bar\": true}"); assertThat(node.isMissingNode()).isFalse(); assertThat(node.fieldNames()).containsOnly("foo", "bar"); assertThat(node.path("foo").intValue()).isEqualTo(4); assertThat(node.path("bar").booleanValue()).isTrue(); } @Test public void producesMissingNodeForMalformedJsonString() { final JsonNode node = ToggleJsonNode.fromString("not a json string"); assertThat(node.isMissingNode()).isTrue(); }
### Question: CachingToggleMap extends ToggleMap<K, T> { @Override public Set<K> keySet() { final Set<K> underlyingKeySet = underlying.keySet(); underlyingKeySet.forEach(cache::refresh); return underlyingKeySet; } CachingToggleMap(ToggleMap<K, T> underlying, CaffeineSpec cacheSpec); CachingToggleMap(ToggleMap<K, T> underlying, String cacheSpec); @Override Toggle<T> apply(K key); @Override Set<K> keySet(); }### Answer: @Test public void testReadKeySetFromUnderlying() { final Set<String> expectedKeySet = new HashSet(); expectedKeySet.add(onKey); expectedKeySet.add(offKey); when(underlying.keySet()).thenReturn(expectedKeySet); final CachingToggleMap<String, Integer> toggleMap = new CachingToggleMap<>(underlying, CaffeineSpec.parse("maximumSize=3")); assertThat(toggleMap.keySet()).containsOnly(onKey, offKey); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.