/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.avro;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.apache.avro.generic.GenericArray;
import org.apache.avro.generic.GenericData;
import org.apache.avro.generic.GenericDatumWriter;
import org.apache.avro.specific.SpecificData;
import org.apache.avro.specific.SpecificDatumWriter;
import org.apache.avro.io.BinaryData;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.io.BinaryEncoder;
import org.apache.avro.util.Utf8;
import org.apache.avro.test.TestRecord;
import org.apache.avro.test.Kind;
import org.apache.avro.test.MD5;
public class TestCompare {
@Test
public void testNull() throws Exception {
Schema schema = Schema.parse("\"null\"");
byte[] b = render(null, schema, new GenericDatumWriter<Object>());
assertEquals(0, BinaryData.compare(b, 0, b, 0, schema));
}
@Test
public void testBoolean() throws Exception {
check("\"boolean\"", Boolean.FALSE, Boolean.TRUE);
}
@Test
public void testString() throws Exception {
check("\"string\"", new Utf8(""), new Utf8("a"));
check("\"string\"", new Utf8("a"), new Utf8("b"));
check("\"string\"", new Utf8("a"), new Utf8("ab"));
check("\"string\"", new Utf8("ab"), new Utf8("b"));
}
@Test
public void testBytes() throws Exception {
check("\"bytes\"",
ByteBuffer.wrap(new byte[]{}),
ByteBuffer.wrap(new byte[]{1}));
check("\"bytes\"",
ByteBuffer.wrap(new byte[]{1}),
ByteBuffer.wrap(new byte[]{2}));
check("\"bytes\"",
ByteBuffer.wrap(new byte[]{1,2}),
ByteBuffer.wrap(new byte[]{2}));
}
@Test
public void testInt() throws Exception {
check("\"int\"", new Integer(-1), new Integer(0));
check("\"int\"", new Integer(0), new Integer(1));
}
@Test
public void testLong() throws Exception {
check("\"long\"", new Long(11), new Long(12));
check("\"long\"", new Long(-1), new Long(1));
}
@Test
public void testFloat() throws Exception {
check("\"float\"", new Float(1.1), new Float(1.2));
check("\"float\"", new Float(-1.1), new Float(1.0));
}
@Test
public void testDouble() throws Exception {
check("\"double\"", new Double(1.2), new Double(1.3));
check("\"double\"", new Double(-1.2), new Double(1.3));
}
@Test
public void testArray() throws Exception {
String json = "{\"type\":\"array\", \"items\": \"long\"}";
Schema schema = Schema.parse(json);
GenericArray<Long> a1 = new GenericData.Array<Long>(1, schema);
a1.add(1L);
GenericArray<Long> a2 = new GenericData.Array<Long>(1, schema);
a2.add(1L);
a2.add(0L);
check(json, a1, a2);
}
@Test
public void testRecord() throws Exception {
String fields = " \"fields\":["
+"{\"name\":\"f\",\"type\":\"int\",\"order\":\"ignore\"},"
+"{\"name\":\"g\",\"type\":\"int\",\"order\":\"descending\"},"
+"{\"name\":\"h\",\"type\":\"int\"}]}";
String recordJson = "{\"type\":\"record\", \"name\":\"Test\","+fields;
Schema schema = Schema.parse(recordJson);
GenericData.Record r1 = new GenericData.Record(schema);
r1.put("f", 1);
r1.put("g", 13);
r1.put("h", 41);
GenericData.Record r2 = new GenericData.Record(schema);
r2.put("f", 0);
r2.put("g", 12);
r2.put("h", 41);
check(recordJson, r1, r2);
r2.put("f", 0);
r2.put("g", 13);
r2.put("h", 42);
check(recordJson, r1, r2);
String record2Json = "{\"type\":\"record\", \"name\":\"Test2\","+fields;
Schema schema2 = Schema.parse(record2Json);
GenericData.Record r3= new GenericData.Record(schema2);
r3.put("f", 1);
r3.put("g", 13);
r3.put("h", 41);
assert(!r1.equals(r3)); // same fields, diff name
}
@Test
public void testEnum() throws Exception {
check("{\"type\":\"enum\", \"name\":\"Test\",\"symbols\": [\"A\", \"B\"]}",
"A", "B");
}
@Test
public void testFixed() throws Exception {
check("{\"type\": \"fixed\", \"name\":\"Test\", \"size\": 1}",
new GenericData.Fixed(new byte[]{(byte)'a'}),
new GenericData.Fixed(new byte[]{(byte)'b'}));
}
@Test
public void testUnion() throws Exception {
check("[\"string\", \"long\"]", new Utf8("a"), new Utf8("b"), false);
check("[\"string\", \"long\"]", new Long(1), new Long(2), false);
check("[\"string\", \"long\"]", new Utf8("a"), new Long(1), false);
}
@Test
public void testSpecificRecord() throws Exception {
TestRecord s1 = new TestRecord();
TestRecord s2 = new TestRecord();
s1.name = new Utf8("foo");
s1.kind = Kind.BAZ;
s1.hash = new MD5();
s1.hash.bytes(new byte[] {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5});
s2.name = new Utf8("bar");
s2.kind = Kind.BAR;
s2.hash = new MD5();
s2.hash.bytes(new byte[] {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,6});
Schema schema = SpecificData.get().getSchema(TestRecord.class);
check(schema, s1, s2, true, new SpecificDatumWriter<TestRecord>(schema),
SpecificData.get());
s2.kind = Kind.BAZ;
check(schema, s1, s2, true, new SpecificDatumWriter<TestRecord>(schema),
SpecificData.get());
}
private static <T> void check(String schemaJson, T o1, T o2)
throws Exception {
check(schemaJson, o1, o2, true);
}
private static <T> void check(String schemaJson, T o1, T o2,
boolean comparable)
throws Exception {
check(Schema.parse(schemaJson), o1, o2, comparable,
new GenericDatumWriter<T>(), GenericData.get());
}
private static <T> void check(Schema schema, T o1, T o2,
boolean comparable,
DatumWriter<T> writer,
GenericData comparator)
throws Exception {
byte[] b1 = render(o1, schema, writer);
byte[] b2 = render(o2, schema, writer);
assertEquals(-1, BinaryData.compare(b1, 0, b2, 0, schema));
assertEquals(1, BinaryData.compare(b2, 0, b1, 0, schema));
assertEquals(0, BinaryData.compare(b1, 0, b1, 0, schema));
assertEquals(0, BinaryData.compare(b2, 0, b2, 0, schema));
assertEquals(-1, compare(o1, o2, schema, comparable, comparator));
assertEquals(1, compare(o2, o1, schema, comparable, comparator));
assertEquals(0, compare(o1, o1, schema, comparable, comparator));
assertEquals(0, compare(o2, o2, schema, comparable, comparator));
assert(o1.equals(o1));
assert(o2.equals(o2));
assert(!o1.equals(o2));
assert(!o2.equals(o1));
assert(!o1.equals(new Object()));
assert(!o2.equals(new Object()));
assert(!o1.equals(null));
assert(!o2.equals(null));
assert(o1.hashCode() != o2.hashCode());
// check BinaryData.hashCode against Object.hashCode
if (schema.getType() != Schema.Type.ENUM) {
assertEquals(o1.hashCode(),
BinaryData.hashCode(b1, 0, b1.length, schema));
assertEquals(o2.hashCode(),
BinaryData.hashCode(b2, 0, b2.length, schema));
}
// check BinaryData.hashCode against GenericData.hashCode
assertEquals(comparator.hashCode(o1, schema),
BinaryData.hashCode(b1, 0, b1.length, schema));
assertEquals(comparator.hashCode(o2, schema),
BinaryData.hashCode(b2, 0, b2.length, schema));
}
@SuppressWarnings(value="unchecked")
private static int compare(Object o1, Object o2, Schema schema,
boolean comparable, GenericData comparator) {
return comparable
? ((Comparable)o1).compareTo(o2)
: comparator.compare(o1, o2, schema);
}
private static <T> byte[] render(T datum, Schema schema,
DatumWriter<T> writer)
throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
writer.setSchema(schema);
writer.write(datum, new BinaryEncoder(out));
return out.toByteArray();
}
}