src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
NullResult implements QueryResult { static NullResult defaultResult() { return defaultResult; } private NullResult(); @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(); }
|
@Test public void testEquals() { NullResult result1 = NullResult.defaultResult(); NullResult result2 = NullResult.defaultResult(); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (NullResult.defaultResult()).equals(0); assertFalse(e); }
@Test public void testHashCode() { NullResult result1 = NullResult.defaultResult(); NullResult result2 = NullResult.defaultResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
GroupCount { private GroupCount(List<FieldRow> groups, long count) { this.groups = groups; this.count = count; } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }
|
@Test public void testGroupCount() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g = GroupCount.create(groups, 10); assertEquals(Collections.singletonList(FieldRow.create("f1", 42)), g.getGroups()); assertEquals(10, g.getCount()); assertEquals("GroupCount(groups=[FieldRow(field=f1, rowID=42, rowKey=)], count=10)", g.toString()); }
|
GroupCount { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof GroupCount)) { return false; } GroupCount rhs = (GroupCount) obj; return new EqualsBuilder() .append(this.groups, rhs.groups) .append(this.count, rhs.count) .isEquals(); } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }
|
@Test public void testEquals() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g = GroupCount.create(groups, 10); assertTrue(g.equals(g)); assertFalse(g.equals(new Integer(10))); }
|
GroupCount { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.groups) .append(this.count) .toHashCode(); } private GroupCount(List<FieldRow> groups, long count); static GroupCount create(List<FieldRow> groups, long count); final List<FieldRow> getGroups(); long getCount(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }
|
@Test public void testHashCode() { List<FieldRow> groups = Collections.singletonList(FieldRow.create("f1", 42)); GroupCount g1 = GroupCount.create(groups, 10); GroupCount g2 = GroupCount.create(groups, 10); assertEquals(g1.hashCode(), g2.hashCode()); }
|
BoolResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BoolResult)) { return false; } return this.changed == ((BoolResult) obj).changed; } @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(); }
|
@Test public void testEquals() { BoolResult result1 = BoolResult.create(true); BoolResult result2 = BoolResult.create(true); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new BoolResult()).equals(0); assertFalse(e); }
|
BoolResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.changed) .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(); }
|
@Test public void testHashCode() { BoolResult result1 = BoolResult.create(false); BoolResult result2 = BoolResult.create(false); assertEquals(result1.hashCode(), result2.hashCode()); }
|
TopNResult implements QueryResult { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TopNResult)) { return false; } TopNResult rhs = (TopNResult) obj; return new EqualsBuilder() .append(this.items, rhs.items) .isEquals(); } @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(); }
|
@Test public void testEquals() { TopNResult result1 = createSampleResult(); TopNResult result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
@Test public void testEqualsFailsWithOtherObject() { @SuppressWarnings("EqualsBetweenInconvertibleTypes") boolean e = (new TopNResult()).equals(0); assertFalse(e); }
|
ValueCountResult implements QueryResult { static ValueCountResult create(long sum, long count) { ValueCountResult result = new ValueCountResult(); result.value = sum; 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(); }
|
@Test public void testEqualsSameObject() { ValueCountResult result = ValueCountResult.create(6, 3); assertEquals(result, result); }
|
TopNResult implements QueryResult { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.items) .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(); }
|
@Test public void testHashCode() { TopNResult result1 = createSampleResult(); TopNResult result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
Validator { public static void ensureValidIndexName(String indexName) { if (!validIndexName(indexName)) { throw new ValidationException(String.format("Invalid index name: %s", indexName)); } } 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); }
|
@Test public void ensureValidIndexNameTest() { String[] validIndexNames = new String[]{ "a", "ab", "ab1", "b-c", "d_e", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" }; for (String name : validIndexNames) { Validator.ensureValidIndexName(name); } }
@Test public void ensureValidIndexNameFailsTest() { String[] invalidIndexNames = new String[]{ "", "'", "^", "/", "\\", "A", "*", "a:b", "valid?no", "yüce", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", "1", "_", "-", }; for (String name : invalidIndexNames) { try { Validator.ensureValidIndexName(name); } catch (ValidationException ex) { continue; } fail("Index name validation should have failed for: " + name); } }
|
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); }
|
@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); } }
|
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); }
|
@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); } }
|
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); }
|
@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); } }
|
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(); }
|
@Test public void testHashCode() { ValueCountResult result1 = ValueCountResult.create(22, 7); ValueCountResult result2 = ValueCountResult.create(22, 7); assertEquals(result1.hashCode(), result2.hashCode()); }
|
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(); }
|
@Test public void testEquals() { GroupCountsResult r1 = createSampleResult(); GroupCountsResult r2 = createSampleResult(); assertTrue(r1.equals(r1)); assertTrue(r1.equals(r2)); assertFalse(r1.equals(new Integer(10))); }
|
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(); }
|
@Test public void testHashCode() { assertEquals(createSampleResult().hashCode(), createSampleResult().hashCode()); }
|
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(); }
|
@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); }
|
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; }
|
@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); }
|
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; }
|
@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()); }
|
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; }
|
@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); }
|
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; }
|
@Test public void toStringTest() { FieldValue a = FieldValue.create(15, 50000); assertEquals("15 = 50000", a.toString()); assertEquals("(default field value)", FieldValue.DEFAULT.toString()); }
|
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; }
|
@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); }
|
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(); }
|
@Test public void testEquals() { CountResultItem result1 = createSampleResult(); CountResultItem result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
|
Util { static Map<String, Object> protobufAttrsToMap(List<Internal.Attr> attrList) { Map<String, Object> attrs = new HashMap<>(attrList.size()); for (Internal.Attr attr : attrList) { Object value; switch ((int) attr.getType()) { case PROTOBUF_STRING_TYPE: value = attr.getStringValue(); break; case PROTOBUF_INT_TYPE: value = attr.getIntValue(); break; case PROTOBUF_BOOL_TYPE: value = attr.getBoolValue(); break; case PROTOBUF_DOUBLE_TYPE: value = attr.getFloatValue(); break; default: throw new PilosaException("Unknown attribute type: " + attr.getType()); } attrs.put(attr.getKey(), value); } return attrs; } }
|
@Test public void protobufAttrsToMapTest() { List<Internal.Attr> attrs = new ArrayList<>(3); attrs.add(Internal.Attr.newBuilder() .setType(Util.PROTOBUF_STRING_TYPE) .setKey("stringval") .setStringValue("somestr") .build()); attrs.add(Internal.Attr.newBuilder() .setType(Util.PROTOBUF_INT_TYPE) .setKey("intval") .setIntValue(5) .build()); attrs.add(Internal.Attr.newBuilder() .setType(Util.PROTOBUF_BOOL_TYPE) .setKey("boolval") .setBoolValue(true) .build()); attrs.add(Internal.Attr.newBuilder() .setKey("doubleval") .setType(Util.PROTOBUF_DOUBLE_TYPE) .setFloatValue(123.5678) .build()); Map<String, Object> m = protobufAttrsToMap(attrs); assertEquals(4, m.size()); assertEquals("somestr", m.get("stringval")); assertEquals(5L, m.get("intval")); assertEquals(true, m.get("boolval")); assertEquals(123.5678, m.get("doubleval")); }
@Test(expected = PilosaException.class) public void protobufAttrsToMapFailsTest() { List<Internal.Attr> attrs = new ArrayList<>(3); attrs.add(Internal.Attr.newBuilder() .setType(9) .setKey("stringval") .setStringValue("somestr") .build()); protobufAttrsToMap(attrs); }
|
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(); }
|
@Test public void testHashCode() { CountResultItem result1 = createSampleResult(); CountResultItem result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
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(); }
|
@Test public void testDefault() { URI uri = URI.defaultURI(); compare(uri, "http", "localhost", 10101); }
|
URI { public static URI address(String address) { URI uri = new URI(); uri._parse(address); 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(); }
|
@Test public void testFull() { URI uri = URI.address("http+protobuf: compare(uri, "http+protobuf", "db1.pilosa.com", 3333); }
@Test public void testFullWithIPv4Host() { URI uri = URI.address("http+protobuf: compare(uri, "http+protobuf", "192.168.1.26", 3333); }
@Test public void testFullWithIPv6Host() { List<Object[]> addresses = Arrays.asList( new Object[]{"[::1]", "http", "[::1]", 10101}, new Object[]{"[::1]:3333", "http", "[::1]", 3333}, new Object[]{"[fd42:4201:f86b:7e09:216:3eff:fefa:ed80]:3333", "http", "[fd42:4201:f86b:7e09:216:3eff:fefa:ed80]", 3333}, new Object[]{"https: ); for (Object[] tuple : addresses) { URI uri = URI.address((String) tuple[0]); compare(uri, (String) tuple[1], (String) tuple[2], (Integer) tuple[3]); } }
@Test public void testHostOnly() { URI uri = URI.address("db1.pilosa.com"); compare(uri, "http", "db1.pilosa.com", 10101); }
@Test public void testPortOnly() { URI uri = URI.address(":5888"); compare(uri, "http", "localhost", 5888); }
@Test public void testHostPort() { URI uri = URI.address("db1.big-data.com:5888"); compare(uri, "http", "db1.big-data.com", 5888); }
@Test public void testSchemeHost() { URI uri = URI.address("https: compare(uri, "https", "db1.big-data.com", 10101); }
@Test public void testSchemePort() { URI uri = URI.address("https: compare(uri, "https", "localhost", 5553); }
@Test(expected = PilosaURIException.class) public void testInvalidAddress1() { URI.address("foo:bar"); }
@Test(expected = PilosaURIException.class) public void testInvalidAddress2() { URI.address("http: }
@Test(expected = PilosaURIException.class) public void testInvalidAddress3() { URI.address("foo:"); }
@Test(expected = PilosaURIException.class) public void testInvalidAddress4() { URI.address(":bar"); }
@Test(expected = PilosaURIException.class) public void testInvalidAddress5() { URI.address("fd42:4201:f86b:7e09:216:3eff:fefa:ed80"); }
@Test public void testEqualsSameObject() { URI uri = URI.address("https: assertEquals(uri, uri); }
|
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(); }
|
@Test public void testHostPortAlternative() { URI uri = URI.fromHostPort("db1.pilosa.com", 3333); compare(uri, "http", "db1.pilosa.com", 3333); }
|
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(); }
|
@Test public void testToString() { URI uri = URI.defaultURI(); assertEquals("http: }
|
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(); }
|
@Test public void testEquals() { URI uri1 = URI.fromHostPort("pilosa.com", 1337); URI uri2 = URI.address("http: boolean e = uri1.equals(uri2); assertTrue(e); }
|
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(); }
|
@Test public void testHashCode() { URI uri1 = URI.defaultURI(); URI uri2 = URI.address("http: assertEquals(uri1.hashCode(), uri2.hashCode()); }
|
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(); }
|
@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); }
|
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(); }
|
@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")); }
|
Field { private Field(Index index, String name, FieldOptions options) { this.index = index; this.name = name; this.options = options; } private Field(Index index, String name, FieldOptions options); Index getIndex(); String getName(); FieldOptions getOptions(); PqlRowQuery row(long rowID); PqlRowQuery row(String rowKey); PqlRowQuery row(boolean rowBool); PqlRowQuery row(long rowID, Date fromTimestamp, Date toTimestamp); PqlRowQuery row(String rowKey, Date fromTimestamp, Date toTimestamp); PqlRowQuery row(boolean rowBool, Date fromTimestamp, Date toTimestamp); PqlBaseQuery set(long rowID, long columnID); PqlBaseQuery set(long rowID, String columnKey); PqlBaseQuery set(String rowKey, long columnID); PqlBaseQuery set(String rowKey, String columnKey); PqlBaseQuery set(boolean rowBool, long columnID); PqlBaseQuery set(boolean rowBool, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(long rowID, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(long rowID, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(String rowKey, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(String rowKey, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(boolean rowBool, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(boolean rowBool, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(long rowID, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(long rowID, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(String rowKey, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(String rowKey, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(boolean rowBool, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(boolean rowBool, String columnKey); PqlBaseQuery topN(long n); @SuppressWarnings("WeakerAccess") PqlBaseQuery topN(long n, PqlRowQuery row); @SuppressWarnings("WeakerAccess") PqlBaseQuery topN(long n, PqlRowQuery row, String attrName, Object... attrValues); @SuppressWarnings("WeakerAccess") PqlRowQuery range(long rowID, Date start, Date end); @SuppressWarnings("WeakerAccess") PqlRowQuery range(String rowKey, Date start, Date end); PqlBaseQuery setRowAttrs(long rowID, Map<String, Object> attributes); PqlBaseQuery setRowAttrs(String rowKey, Map<String, Object> attributes); PqlBaseQuery store(PqlRowQuery row, long rowID); PqlBaseQuery store(PqlRowQuery row, String rowKey); PqlBaseQuery clearRow(long rowID); PqlBaseQuery clearRow(String rowKey); PqlBaseQuery clearRow(boolean rowBool); PqlRowQuery lessThan(long n); PqlRowQuery lessThanOrEqual(long n); PqlRowQuery greaterThan(long n); PqlRowQuery greaterThanOrEqual(long n); PqlRowQuery equals(long n); PqlRowQuery notEquals(long n); PqlRowQuery notNull(); PqlRowQuery between(long a, long b); PqlBaseQuery sum(); PqlBaseQuery sum(PqlRowQuery row); PqlBaseQuery min(); PqlBaseQuery min(PqlRowQuery row); PqlBaseQuery max(); PqlBaseQuery max(PqlRowQuery row); PqlBaseQuery setValue(long columnID, long value); PqlBaseQuery setValue(String columnKey, long value); PqlRowsQuery rows(); PqlRowsQuery rows(long limit); PqlRowsQuery rows(long limit, long columnID); PqlRowsQuery rows(long limit, String columnKey); PqlRowsQuery rows(long previousRowID, long limit, long columnID); PqlRowsQuery rows(long previousRowID, long limit, String columnKey); PqlRowsQuery rows(String previousRowKey, long limit, long columnID); PqlRowsQuery rows(String previousRowKey, long limit, String columnKey); PqlRowsQuery rows(boolean previousRowBool, long limit, long columnID); PqlRowsQuery rows(boolean previousRowBool, long limit, String columnKey); @Override boolean equals(Object obj); @Override int hashCode(); }
|
@Test(expected = ValidationException.class) public void checkValidatorWasCalledTest() { Field field = this.index.field("a:b"); }
@Test public void testEqualsSameObject() { Field field = this.index.field("some-field"); assertEquals(field, field); }
|
Field { @Override public int hashCode() { return new HashCodeBuilder(31, 47) .append(this.index.getName()) .append(this.options) .toHashCode(); } private Field(Index index, String name, FieldOptions options); Index getIndex(); String getName(); FieldOptions getOptions(); PqlRowQuery row(long rowID); PqlRowQuery row(String rowKey); PqlRowQuery row(boolean rowBool); PqlRowQuery row(long rowID, Date fromTimestamp, Date toTimestamp); PqlRowQuery row(String rowKey, Date fromTimestamp, Date toTimestamp); PqlRowQuery row(boolean rowBool, Date fromTimestamp, Date toTimestamp); PqlBaseQuery set(long rowID, long columnID); PqlBaseQuery set(long rowID, String columnKey); PqlBaseQuery set(String rowKey, long columnID); PqlBaseQuery set(String rowKey, String columnKey); PqlBaseQuery set(boolean rowBool, long columnID); PqlBaseQuery set(boolean rowBool, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(long rowID, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(long rowID, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(String rowKey, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(String rowKey, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(boolean rowBool, long columnID, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery set(boolean rowBool, String columnKey, Date timestamp); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(long rowID, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(long rowID, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(String rowKey, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(String rowKey, String columnKey); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(boolean rowBool, long columnID); @SuppressWarnings("WeakerAccess") PqlBaseQuery clear(boolean rowBool, String columnKey); PqlBaseQuery topN(long n); @SuppressWarnings("WeakerAccess") PqlBaseQuery topN(long n, PqlRowQuery row); @SuppressWarnings("WeakerAccess") PqlBaseQuery topN(long n, PqlRowQuery row, String attrName, Object... attrValues); @SuppressWarnings("WeakerAccess") PqlRowQuery range(long rowID, Date start, Date end); @SuppressWarnings("WeakerAccess") PqlRowQuery range(String rowKey, Date start, Date end); PqlBaseQuery setRowAttrs(long rowID, Map<String, Object> attributes); PqlBaseQuery setRowAttrs(String rowKey, Map<String, Object> attributes); PqlBaseQuery store(PqlRowQuery row, long rowID); PqlBaseQuery store(PqlRowQuery row, String rowKey); PqlBaseQuery clearRow(long rowID); PqlBaseQuery clearRow(String rowKey); PqlBaseQuery clearRow(boolean rowBool); PqlRowQuery lessThan(long n); PqlRowQuery lessThanOrEqual(long n); PqlRowQuery greaterThan(long n); PqlRowQuery greaterThanOrEqual(long n); PqlRowQuery equals(long n); PqlRowQuery notEquals(long n); PqlRowQuery notNull(); PqlRowQuery between(long a, long b); PqlBaseQuery sum(); PqlBaseQuery sum(PqlRowQuery row); PqlBaseQuery min(); PqlBaseQuery min(PqlRowQuery row); PqlBaseQuery max(); PqlBaseQuery max(PqlRowQuery row); PqlBaseQuery setValue(long columnID, long value); PqlBaseQuery setValue(String columnKey, long value); PqlRowsQuery rows(); PqlRowsQuery rows(long limit); PqlRowsQuery rows(long limit, long columnID); PqlRowsQuery rows(long limit, String columnKey); PqlRowsQuery rows(long previousRowID, long limit, long columnID); PqlRowsQuery rows(long previousRowID, long limit, String columnKey); PqlRowsQuery rows(String previousRowKey, long limit, long columnID); PqlRowsQuery rows(String previousRowKey, long limit, String columnKey); PqlRowsQuery rows(boolean previousRowBool, long limit, long columnID); PqlRowsQuery rows(boolean previousRowBool, long limit, String columnKey); @Override boolean equals(Object obj); @Override int hashCode(); }
|
@Test public void testHashCode() { FieldOptions options1 = FieldOptions.builder() .fieldTime(TimeQuantum.YEAR_MONTH_DAY) .build(); FieldOptions options2 = FieldOptions.builder() .fieldTime(TimeQuantum.YEAR_MONTH_DAY) .build(); Field field1 = this.index.field("field1", options1); Field field2 = this.index.field("field2", options2); assertEquals(field1.hashCode(), field2.hashCode()); }
|
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(); }
|
@Test public void testEqualsSameObject() { FieldOptions options = FieldOptions.builder().build(); assertEquals(options, options); }
|
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(); }
|
@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()); }
|
FieldOptions { public static FieldOptions fromMap(final Map<String, Object> map) { String fieldTypeStr = (String)map.get("type"); if (fieldTypeStr == null) { fieldTypeStr = FieldType.SET.toString(); } FieldType fieldType = FieldType.fromString(fieldTypeStr); Builder builder = builder(); builder.setFieldType(fieldType); for (Map.Entry<String, Object> entry : map.entrySet()) { Object value = entry.getValue(); switch (entry.getKey()) { case "type": continue; case "keys": builder.setKeys((Boolean)entry.getValue()); continue; case "cacheType": if (!fieldType.equals(FieldType.SET) && !fieldType.equals(FieldType.MUTEX)) { throw new IllegalArgumentException("cacheType option is valid only for set and mutex fields"); } CacheType cacheType = CacheType.fromString((String)value); builder.setCacheType(cacheType); continue; case "cacheSize": if (!fieldType.equals(FieldType.SET) && !fieldType.equals(FieldType.MUTEX)) { throw new IllegalArgumentException("cacheSize option is valid only for set and mutex fields"); } builder.setCacheSize(((Number) value).intValue()); continue; case "timeQuantum": if (!fieldType.equals(FieldType.TIME)) { throw new IllegalArgumentException("timeQuantum option is valid only for time fields"); } TimeQuantum timeQuantum = TimeQuantum.fromString((String)value); builder.setTimeQuantum(timeQuantum); continue; case "min": if (!fieldType.equals(FieldType.INT)) { throw new IllegalArgumentException("min option is valid only for int fields"); } builder.setMin(((Number) value).longValue()); continue; case "max": if (!fieldType.equals(FieldType.INT)) { throw new IllegalArgumentException("max option is valid only for int fields"); } builder.setMax(((Number) value).longValue()); continue; default: throw new IllegalArgumentException(String.format("Unknown field option: '%s'", entry.getKey())); } } return builder.build(); } 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(); }
|
@Test(expected = IllegalArgumentException.class) public void testCacheTypeRequiresSetField() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "int"); optionsMap.put("cacheType", "ranked"); FieldOptions options = FieldOptions.fromMap(optionsMap); }
@Test(expected = IllegalArgumentException.class) public void testCacheSizeRequiresSetField() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "int"); optionsMap.put("cacheSize", 1000); FieldOptions options = FieldOptions.fromMap(optionsMap); }
@Test(expected = IllegalArgumentException.class) public void testTimeQuantumRequiresTimeField() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "set"); optionsMap.put("timeQuantum", "YMDH"); FieldOptions options = FieldOptions.fromMap(optionsMap); }
@Test(expected = IllegalArgumentException.class) public void testMinRequiresIntField() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "set"); optionsMap.put("min", 1000); FieldOptions options = FieldOptions.fromMap(optionsMap); }
@Test(expected = IllegalArgumentException.class) public void testMaxRequiresIntField() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "set"); optionsMap.put("max", 1000); FieldOptions options = FieldOptions.fromMap(optionsMap); }
@Test(expected = ValidationException.class) public void testInvalidType() { Map<String, Object> optionsMap = new HashMap<>(); optionsMap.put("type", "foo"); FieldOptions options = FieldOptions.fromMap(optionsMap); }
|
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(); }
|
@Test(expected = ValidationException.class) public void checkValidatorWasCalledTest() { Index.create("a:b"); }
|
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(); }
|
@Test public void testEqualsSameObject() { Index index = this.schema.index("some-index"); assertEquals(index, index); }
|
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(); }
|
@Test public void testHashCode() { Index index1 = this.schema.index("foo"); Index index2 = Index.create("foo"); assertEquals(index1.hashCode(), index2.hashCode()); }
|
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(); }
|
@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")); }
|
Schema { public Schema diff(Schema other) { Schema result = Schema.defaultSchema(); for (Map.Entry<String, Index> indexEntry : this.indexes.entrySet()) { String indexName = indexEntry.getKey(); Index index = indexEntry.getValue(); if (!other.indexes.containsKey(indexName)) { result.indexes.put(indexName, new Index(indexEntry.getValue())); } else { Index otherIndex = other.indexes.get(indexName); Index resultIndex = Index.create(indexName, otherIndex.getOptions()); Map<String, Field> otherIndexFields = otherIndex.getFields(); for (Map.Entry<String, Field> fieldEntry : index.getFields().entrySet()) { String fieldName = fieldEntry.getKey(); if (!otherIndexFields.containsKey(fieldName)) { resultIndex.field(fieldName, fieldEntry.getValue().getOptions()); } } if (resultIndex.getFields().size() > 0) { result.indexes.put(indexName, resultIndex); } } } return result; } 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(); }
|
@Test public void diffTest() { Schema schema1 = Schema.defaultSchema(); Index index11 = makeIndex(schema1, "index11"); makeField(index11, "index11-f1"); makeField(index11, "index11-f2", true); Index index12 = makeIndex(schema1, "index12", true); makeField(index12, "index12-f1"); Index index13 = makeIndex(schema1, "index13", true); makeField(index13, "index13-f1", true); Schema schema2 = Schema.defaultSchema(); Index index21 = makeIndex(schema2, "index21"); makeField(index21, "index21-f1"); Index s2Index13 = makeIndex(schema2, "index13", true); makeField(s2Index13, "index13-f2"); Schema target = Schema.defaultSchema(); Index targetIndex11 = makeIndex(target, "index11"); makeField(targetIndex11, "index11-f1"); makeField(targetIndex11, "index11-f2", true); Index targetIndex12 = makeIndex(target, "index12", true); makeField(targetIndex12, "index12-f1"); Index targetIndex13 = makeIndex(target, "index13", true); makeField(targetIndex13, "index13-f1", true); Schema diff = schema1.diff(schema2); assertEquals(target, diff); }
|
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(); }
|
@Test public void testHashCode() { Schema schema1 = Schema.defaultSchema(); schema1.index("foo"); Schema schema2 = Schema.defaultSchema(); schema2.index("foo"); assertEquals(schema1.hashCode(), schema2.hashCode()); }
|
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(); }
|
@Test public void testHasIndex() { Schema schema = Schema.defaultSchema(); schema.index("some-index"); assertTrue(schema.hasIndex("some-index")); assertFalse(schema.hasIndex("nonexistent-index")); }
|
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(); }
|
@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); }
|
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(); }
|
@Test public void testEqualsSameObject() { IntResult result = IntResult.create(6); assertEquals(result, result); }
|
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(); }
|
@Test public void testEqualsSameObject() { IndexOptions options = IndexOptions.builder().build(); assertEquals(options, options); }
|
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(); }
|
@Test public void testEquals() { IndexOptions options1, options2; options1 = IndexOptions.builder() .setKeys(true) .build(); options2 = IndexOptions.builder() .setKeys(true) .build(); assertEquals(options1, options2); }
|
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(); }
|
@Test public void testHashCode() { IndexOptions options1, options2; options1 = IndexOptions.builder() .setKeys(true) .build(); options2 = IndexOptions.builder() .setKeys(true) .build(); assertEquals(options1.hashCode(), options2.hashCode()); }
|
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(); }
|
@Test public void testRowResultToString() { RowResult result = createSampleResult(); String s = result.toString(); assertEquals("RowResult(attrs={color=blue}, columns=[42, 45], keys=[])", s); }
|
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(); }
|
@Test public void testEquals() { RowResult result1 = createSampleResult(); RowResult result2 = createSampleResult(); boolean e = result1.equals(result2); assertTrue(e); }
|
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(); }
|
@Test public void testHashCode() { RowResult result1 = createSampleResult(); RowResult result2 = createSampleResult(); assertEquals(result1.hashCode(), result2.hashCode()); }
|
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(); }
|
@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()); }
|
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(); }
|
@Test public void testHashCode() { IntResult result1 = IntResult.create(22); IntResult result2 = IntResult.create(22); assertEquals(result1.hashCode(), result2.hashCode()); }
|
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); }
|
@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)); } }
|
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); }
|
@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"))); }
|
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); }
|
@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)); }
|
Precoded implements UriEncoded { @Override public UriEncoded normalized() { if (mNormalized == null) { mNormalized = new Normalized(this); } return mNormalized; } 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(); }
|
@Test public void normalized() throws Exception { assertEquals("", new Precoded("").normalized().toString()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new Precoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").normalized().toString()); assertEquals(".-_~", new Precoded(".-_~").normalized().toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+", new Precoded("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+").normalized().toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+ab0", new Precoded("%25%2f%22%26%3D%c3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%ac%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%c3%A0%C3%A8%C3%b2%C3%b9%c3%a2%20+%61%62%30").normalized().toString()); }
|
Precoded implements UriEncoded { @Override public CharSequence decoded(String charset) throws UnsupportedEncodingException { if ("UTF-8".equalsIgnoreCase(charset)) { return decoded(); } return decoded(mEncoded, mStart, mEnd, charset); } 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(); }
|
@Test public void testDecoded() throws Exception { assertEquals("", new Precoded("").decoded()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new Precoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").decoded()); assertEquals(".-_~", new Precoded(".-_~").decoded()); assertEquals("%/\"&=ÜÖÄa¹²³¼½¬@æſðđŋħłł€¶ŧ←↓→øþ«¢„“”µ…·âôêàèòùâ +", new Precoded("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+").decoded()); }
@Test public void decoded() throws Exception { }
|
Normalized implements UriEncoded { @Override public String toString() { if (mNormalized == null) { mNormalized = normalized(mDelegate); } return mNormalized.toString(); } Normalized(UriEncoded delegate); @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(); }
|
@Test public void testToString() throws Exception { assertEquals("", new Normalized(new Precoded("")).normalized().toString()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new Precoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").normalized().toString()); assertEquals(".-_~", new Normalized(new Precoded(".-_~")).normalized().toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+", new Normalized(new Precoded("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+")).toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+ab0", new Normalized(new Precoded("%25%2f%22%26%3D%c3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%ac%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%c3%A0%C3%A8%C3%b2%C3%b9%c3%a2%20+%61%62%30")).toString()); }
|
FormEncoded implements UriEncoded { @Override public String toString() { if (mEncoded == null) { try { mEncoded = encoded(mPlain, mCharSet); } catch (UnsupportedEncodingException e) { throw new IllegalArgumentException(String.format("Charset %s not supported by Runtime", mCharSet)); } } return mEncoded.toString(); } FormEncoded(CharSequence plain); FormEncoded(CharSequence plain, String charSet); @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(); }
|
@Test public void testToString() throws Exception { assertEquals("", new FormEncoded("").toString()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new FormEncoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").toString()); assertEquals(".-_~", new FormEncoded(".-_~").toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2+", new FormEncoded("%/\"&=ÜÖÄa¹²³¼½¬@æſðđŋħłł€¶ŧ←↓→øþ«¢„“”µ…·âôêàèòùâ ").toString()); assertEquals("%2B+%0D%0A", new FormEncoded("+ \n").toString()); assertEquals("%2B+%0D%0A", new FormEncoded("+ \r\n").toString()); }
|
EncodedPath implements Path { @Override public boolean isEmpty() { return mPath.length() == 0; } EncodedPath(UriEncoded path); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@Test public void iterator() throws Exception { }
|
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; }
|
@Test public void isEmpty() throws Exception { assertTrue(new EmptyPath().isEmpty()); }
|
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; }
|
@Test public void isAbsolute() throws Exception { assertFalse(new EmptyPath().isAbsolute()); }
|
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; }
|
@Test public void iterator() throws Exception { assertFalse(new EmptyPath().iterator().hasNext()); }
|
Encoded implements UriEncoded { @Override public String toString() { if (mEncoded == null) { try { mEncoded = encoded(mPlain, mCharSet); } catch (UnsupportedEncodingException e) { throw new IllegalArgumentException(String.format("Charset %s not supported by Runtime", mCharSet)); } } return mEncoded.toString(); } Encoded(CharSequence plain); Encoded(CharSequence plain, String charSet); @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(); }
|
@Test public void testToString() throws Exception { assertEquals("", new Encoded("").toString()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new Encoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").toString()); assertEquals(".-_~", new Encoded(".-_~").toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20", new Encoded("%/\"&=ÜÖÄa¹²³¼½¬@æſðđŋħłł€¶ŧ←↓→øþ«¢„“”µ…·âôêàèòùâ ").toString()); }
|
StructuredPath implements Path { @Override public boolean isEmpty() { return mPathSegments.length == 0; } StructuredPath(UriEncoded... segments); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@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"))); }
|
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(); }
|
@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()); }
|
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(); }
|
@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)); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
Extended implements Path { @Override public Iterator<UriEncoded> iterator() { return Collections.unmodifiableList(normalize(new SerialIterator<>(mDelegate.iterator(), mNewSegments.iterator()))).iterator(); } 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(); }
|
@Test public void iterator() throws Exception { assertThat(new Extended(EmptyPath.INSTANCE, EmptyPath.INSTANCE), new IsEmptyIterable<UriEncoded>()); assertThat(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Extended(new EncodedPath(new Precoded("/")), EmptyPath.INSTANCE), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("./c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("../c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("./c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("../c"))), Matchers.contains((UriEncoded) new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("./c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("../c"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("./c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c"))); assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../../."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../../.."))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY)); assertThat(new Extended(new StructuredPath(new Encoded("a"), new Encoded("b")), IdempotentEncoded.CURRENT, new Encoded("c")), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c"))); assertThat(new Extended(new StructuredPath(new Encoded("a"), new Encoded("b")), IdempotentEncoded.PARENT, new Encoded("c")), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c"))); }
|
FormPrecoded implements UriEncoded { @Override public UriEncoded normalized() { if (mNormalized == null) { mNormalized = new Normalized(this); } return mNormalized; } FormPrecoded(CharSequence encoded); @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(); }
|
@Test public void normalized() throws Exception { assertEquals("", new FormPrecoded("").normalized().toString()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new FormPrecoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").normalized().toString()); assertEquals(".-_~", new FormPrecoded(".-_~").normalized().toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+", new FormPrecoded("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+").normalized().toString()); assertEquals("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+ab0", new FormPrecoded("%25%2f%22%26%3D%c3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%ac%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%c3%A0%C3%A8%C3%b2%C3%b9%c3%a2%20+%61%62%30").normalized().toString()); }
|
Normalized implements Path { @Override public boolean isEmpty() { return mDelegate.isEmpty(); } Normalized(Path delegate); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@Test public void testIsEmpty() throws Exception { assertTrue(new Normalized(new EncodedPath(new Precoded(""))).isEmpty()); assertFalse(new Normalized(new EncodedPath(new Precoded("/"))).isEmpty()); }
|
Normalized implements Path { @Override public boolean isAbsolute() { return mDelegate.isAbsolute(); } Normalized(Path delegate); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@Test public void testIsAbsolute() throws Exception { assertFalse(new Normalized(new EncodedPath(new Precoded("abc"))).isAbsolute()); assertTrue(new Normalized(new EncodedPath(new Precoded("/"))).isAbsolute()); }
|
Normalized implements Path { @Override public Iterator<UriEncoded> iterator() { if (mDelegate.isEmpty()) { return EmptyIterator.instance(); } return Collections.unmodifiableList(normalize(mDelegate.iterator())).iterator(); } Normalized(Path delegate); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@Test public void testIterator() throws Exception { assertThat(new Normalized(EmptyPath.INSTANCE), new IsEmptyIterable()); assertThat(new Normalized(new EncodedPath(new Precoded("."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded(".."))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("/"))), Matchers.contains((UriEncoded) new Encoded(""), new Encoded(""))); assertThat(new Normalized(new EncodedPath(new Precoded("/a"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"))); assertThat(new Normalized(new EncodedPath(new Precoded("/a/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("/a/b"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("a"))), Matchers.contains((UriEncoded) new Encoded("a"))); assertThat(new Normalized(new EncodedPath(new Precoded("a/"))), Matchers.contains((UriEncoded) new Encoded("a"), IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("a/b"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("/../a/b"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("/../a/../b"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("../a/b"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("../a/../b"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("/../../a/../b/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("../../c"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, new Encoded("c"))); assertThat(new Normalized(new EncodedPath(new Precoded("/../../c/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"), IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("./a/b/./././c"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c"))); assertThat(new Normalized(new EncodedPath(new Precoded("a/../b"))), Matchers.contains((UriEncoded) new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../.."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../"))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../.."))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../../"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY)); assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../../c"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("c"))); assertThat(new Normalized(new EncodedPath(new Precoded("../a/../../b"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("./a/./../b"))), Matchers.contains((UriEncoded) new Encoded("b"))); assertThat(new Normalized(new EncodedPath(new Precoded("../a/../../b/../"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY)); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
Resolved implements Path { @Override public Iterator<UriEncoded> iterator() { if (mReference.isEmpty()) { return Collections.unmodifiableList(normalize(mBase.iterator())).iterator(); } if (mReference.isAbsolute()) { return Collections.unmodifiableList(normalize(mReference.iterator())).iterator(); } LinkedList<UriEncoded> segments = normalize(mBase.iterator()); if (!segments.isEmpty()) { UriEncoded last = segments.getLast(); if (!IdempotentEncoded.EMPTY.equals(last) && !IdempotentEncoded.CURRENT.equals(last) && !IdempotentEncoded.PARENT.equals(last)) { segments.removeLast(); } } return Collections.unmodifiableList(normalize(new SerialIterator<>(segments.iterator(), mReference.iterator()))).iterator(); } Resolved(Path base, Path reference); @Override boolean isEmpty(); @Override boolean isAbsolute(); @Override Iterator<UriEncoded> iterator(); }
|
@Test public void testIterator() throws Exception { assertThat(new Resolved(EmptyPath.INSTANCE, EmptyPath.INSTANCE), new IsEmptyIterable<UriEncoded>()); assertThat(new Resolved(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/")), EmptyPath.INSTANCE), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b")), new EncodedPath(new Precoded("g"))), Matchers.contains((UriEncoded) new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b")), new EncodedPath(new Precoded("./g"))), Matchers.contains((UriEncoded) new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b")), new EncodedPath(new Precoded("../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/")), new EncodedPath(new Precoded("g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/")), new EncodedPath(new Precoded("./g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/")), new EncodedPath(new Precoded("../g"))), Matchers.contains((UriEncoded) new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded(".")), new EncodedPath(new Precoded("."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("./g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g/"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("/g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded(";x"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Precoded(";x"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded(""))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Precoded("d;p"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("./"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded(".."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../.."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../../"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../../../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("../../../../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("/./g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("/../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g."))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded(".g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded(".g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g.."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g.."))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("..g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("..g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("./../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("./g/."))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g/./h"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("g"), new Encoded("h"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g/../h"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("h"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g;x=1/./y"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Precoded("g;x=1"), new Encoded("y"))); assertThat(new Resolved(new EncodedPath(new Precoded("/b/c/d;p")), new EncodedPath(new Precoded("g;x=1/../y"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), new Encoded("c"), new Encoded("y"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("./g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g/"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("/g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded(";x"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Precoded(";x"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded(""))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Precoded("d;p"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("."))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("./"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded(".."))), Matchers.contains((UriEncoded) new Encoded("b"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../"))), Matchers.contains((UriEncoded) new Encoded("b"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../.."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../../"))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../../g"))), Matchers.contains((UriEncoded) new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../../../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("../../../../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("/./g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("/../g"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g."))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g."))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded(".g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded(".g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g.."))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g.."))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("..g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("..g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("./../g"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("g"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("./g/."))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g"), IdempotentEncoded.EMPTY)); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g/./h"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("g"), new Encoded("h"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g/../h"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("h"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g;x=1/./y"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Precoded("g;x=1"), new Encoded("y"))); assertThat(new Resolved(new EncodedPath(new Precoded("b/c/d;p")), new EncodedPath(new Precoded("g;x=1/../y"))), Matchers.contains((UriEncoded) new Encoded("b"), new Encoded("c"), new Encoded("y"))); }
|
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(); }
|
@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()); }
|
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(); }
|
@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()); }
|
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(); }
|
@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: }
|
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(); }
|
@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: }
|
FormPrecoded implements UriEncoded { @Override public String toString() { return mEncoded.toString(); } FormPrecoded(CharSequence encoded); @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(); }
|
@Test public void testToString() throws Exception { assertEquals("", new FormPrecoded("").decoded()); assertEquals("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", new FormPrecoded("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").decoded()); assertEquals(".-_~", new FormPrecoded(".-_~").decoded()); assertEquals("%/\"&=ÜÖÄa¹²³¼½¬@æſðđŋħłł€¶ŧ←↓→øþ«¢„“”µ…·âôêàèòùâ ", new FormPrecoded("%25%2F%22%26%3D%C3%9C%C3%96%C3%84a%C2%B9%C2%B2%C2%B3%C2%BC%C2%BD%C2%AC%40" + "%C3%A6%C5%BF%C3%B0%C4%91%C5%8B%C4%A7%C5%82%C5%82%E2%82%AC%C2%B6%C5" + "%A7%E2%86%90%E2%86%93%E2%86%92%C3%B8%C3%BE%C2%AB%C2%A2%E2%80%9E%E2" + "%80%9C%E2%80%9D%C2%B5%E2%80%A6%C2%B7%C3%A2%C3%B4%C3%AA%C3%A0%C3%A8%C3%B2%C3%B9%C3%A2%20+").decoded()); }
|
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(); }
|
@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: }
|
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(); }
|
@Test public void isHierarchical() throws Exception { assertFalse(new LazyUri(new Precoded("mailto:[email protected]")).isHierarchical()); assertTrue(new LazyUri(new Precoded("http: }
|
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(); }
|
@Test public void isAbsolute() throws Exception { assertFalse(new LazyUri(new Precoded("/some/path")).isAbsolute()); assertTrue(new LazyUri(new Precoded("http: }
|
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(); }
|
@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()); }
|
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; }
|
@Test public void testScheme() throws Exception { assertFalse(new EmptyUri().scheme().isPresent()); }
|
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; }
|
@Test public void testAuthority() throws Exception { assertFalse(new EmptyUri().authority().isPresent()); }
|
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; }
|
@Test public void testPath() throws Exception { assertTrue(new EmptyUri().path().isEmpty()); }
|
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; }
|
@Test public void testQuery() throws Exception { assertFalse(new EmptyUri().query().isPresent()); }
|
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; }
|
@Test public void testFragment() throws Exception { assertFalse(new EmptyUri().fragment().isPresent()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.