+++ /dev/null
-package org.apache.lucene.facet.taxonomy;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-
-import org.junit.Test;
-
-import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.facet.taxonomy.CategoryPath;
-
-/**
- * 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.
- */
-
-public class TestCategoryPath extends LuceneTestCase {
-
- @Test
- public void testBasic() {
- CategoryPath p = new CategoryPath(0,0);
- assertEquals(0, p.length());
- for (int i=0; i<1000; i++) {
- p.add("hello");
- assertEquals(i+1, p.length());
- }
- }
-
- @Test
- public void testConstructorCapacity() {
- CategoryPath p = new CategoryPath(0,0);
- assertEquals(0, p.capacityChars());
- assertEquals(0, p.capacityComponents());
- assertEquals(0, p.length());
- p = new CategoryPath(5,18);
- assertEquals(5, p.capacityChars());
- assertEquals(18, p.capacityComponents());
- assertEquals(0, p.length());
- p = new CategoryPath(27,13);
- assertEquals(27, p.capacityChars());
- assertEquals(13, p.capacityComponents());
- assertEquals(0, p.length());
- }
-
- @Test
- public void testClear() {
- CategoryPath p = new CategoryPath(0,0);
- p.add("hi");
- p.add("there");
- assertEquals(2, p.length());
- p.clear();
- assertEquals(0, p.length());
- p.add("yo!");
- assertEquals(1, p.length());
- }
-
- @Test
- public void testTrim() {
- CategoryPath p = new CategoryPath(0,0);
- p.add("this");
- p.add("message");
- p.add("will");
- p.add("self");
- p.add("destruct");
- p.add("in");
- p.add("five");
- p.add("seconds");
- assertEquals(8, p.length());
- p.trim(3);
- assertEquals(5, p.length());
- p.trim(0); // no-op
- assertEquals(5, p.length());
- p.trim(-3); // no-op
- assertEquals(5, p.length());
- p.trim(1);
- assertEquals(4, p.length());
- p.trim(8); // clear
- assertEquals(0, p.length());
- p.add("yo!");
- assertEquals(1, p.length());
- p.trim(1); // clear
- assertEquals(0, p.length());
- }
-
- @Test
- public void testComponentsLimit() {
- // Test that we can add up to 2^15-1 components
- CategoryPath p = new CategoryPath(0,0);
- for (int i=0; i<32767; i++) {
- p.add("");
- assertEquals(i+1, p.length());
- }
- // Also see that in the current implementation, this is actually
- // the limit: if we add one more component, things break (because
- // we used a short to hold ncomponents). See that it breaks in the
- // way we expect it to:
- p.add(""); // this still works, but...
- assertEquals(-32768, p.length()); // now the length is wrong and negative
- }
-
- @Test
- public void testCharsLimit() {
- // Test that we can add up to 2^15-1 characters
- CategoryPath p = new CategoryPath(0,0);
- for (int i=0; i<8192; i++) {
- p.add("aaaa");
- }
- // Also see that in the current implementation, this is actually the
- // limit: If we add one more character, things break (because ends[]
- // is an array of shorts), and we actually get an exception.
- try {
- p.add("a");
- fail("Should have thrown an exception");
- } catch (ArrayIndexOutOfBoundsException e) {
- // good.
- }
- }
-
- @Test
- public void testToString() {
- CategoryPath p = new CategoryPath(0,0);
- // When the category is empty, we expect an empty string
- assertEquals("", p.toString('/'));
- // This is (deliberately, in our implementation) indistinguishable
- // from the case of a single empty component:
- p.add("");
- assertEquals("", p.toString('/'));
- // Check just one category (so no delimiter needed):
- p.clear();
- p.add("hello");
- assertEquals("hello", p.toString('/'));
- // Now for two categories:
- p.clear();
- p.add("hello");
- p.add("world");
- assertEquals("hello/world", p.toString('/'));
- // And for a thousand...
- p.clear();
- p.add("0");
- StringBuilder expected = new StringBuilder("0");
- for (int i=1; i<1000; i++) {
- String num = Integer.toString(i);
- p.add(num);
- expected.append('/');
- expected.append(num);
- }
- assertEquals(expected.toString(), p.toString('/'));
- // Check that toString() without a parameter just defaults to '/':
- assertEquals(expected.toString(), p.toString());
- }
-
- // testing toString() and its variants already test most of the appendTo()
- // code, but not all of it (the "eclemma" code-coverage tool discovered
- // this for us). Here we complete the coverage of the appendTo() methods:
- @Test
- public void testAppendTo() throws IOException {
- CategoryPath p = new CategoryPath(0,0);
- StringBuilder sb = new StringBuilder();
- p.appendTo(sb, '/');
- assertEquals(0, sb.length());
- p.appendTo(sb, '/', -1);
- assertEquals(0, sb.length());
- p.appendTo(sb, '/', 1);
- assertEquals(0, sb.length());
- p.appendTo(sb, '/', -1, 1);
- assertEquals(0, sb.length());
- }
-
- @Test
- public void testLastComponent() {
- CategoryPath p = new CategoryPath(1000,1000);
- // When the category is empty, we expect a null
- assertNull(p.lastComponent());
- for (int i=0; i<=100; i++) {
- String num = Integer.toString(i);
- p.add(num);
- assertEquals(num, p.lastComponent());
- }
- }
-
- @Test
- public void testGetComponent() {
- CategoryPath p = new CategoryPath(1000,1000);
- // When the category is empty, we expect a null
- assertNull(p.getComponent(0));
- assertNull(p.getComponent(1));
- assertNull(p.getComponent(-1));
- for (int i=0; i<=100; i++) {
- p.add(Integer.toString(i));
- for (int j=0; j<=i; j++) {
- assertEquals(j, Integer.parseInt(p.getComponent(j)));
- }
- assertNull(p.getComponent(-1));
- assertNull(p.getComponent(i+1));
- }
- }
-
- @Test
- public void testToStringPrefix() {
- CategoryPath p = new CategoryPath(0,0);
- p.add("hi");
- p.add("there");
- p.add("man");
- assertEquals("hi/there/man", p.toString('/'));
- assertEquals("", p.toString('/', 0));
- assertEquals("hi", p.toString('/', 1));
- assertEquals("hi/there", p.toString('/', 2));
- assertEquals("hi/there/man", p.toString('/', 3));
- assertEquals("hi/there/man", p.toString('/', 4));
- assertEquals("hi/there/man", p.toString('/', -1));
- }
-
- @Test
- public void testToStringSubpath() {
- CategoryPath p = new CategoryPath(0,0);
- assertEquals("", p.toString('/', 0, 0));
- p.add("hi");
- p.add("there");
- p.add("man");
- assertEquals("", p.toString('/', 0, 0));
- assertEquals("hi", p.toString('/', 0, 1));
- assertEquals("hi/there", p.toString('/', 0, 2));
- assertEquals("hi/there/man", p.toString('/', 0, 3));
- assertEquals("hi/there/man", p.toString('/', 0, 4));
- assertEquals("hi/there/man", p.toString('/', 0, -1));
- assertEquals("hi/there/man", p.toString('/', -1, -1));
- assertEquals("there/man", p.toString('/', 1, -1));
- assertEquals("man", p.toString('/', 2, -1));
- assertEquals("", p.toString('/', 3, -1));
- assertEquals("there/man", p.toString('/', 1, 3));
- assertEquals("there", p.toString('/', 1, 2));
- assertEquals("", p.toString('/', 1, 1));
- }
-
- @Test
- public void testDelimiterConstructor() {
- // Test that the constructor that takes a string and a delimiter
- // works correctly. Also check that it allocates exactly the needed
- // needed size for the array - not more.
- CategoryPath p = new CategoryPath("", '/');
- assertEquals(p.length(), 0);
- assertEquals(p.capacityChars(), 0);
- assertEquals(p.capacityComponents(), 0);
- p = new CategoryPath("hello", '/');
- assertEquals(p.length(), 1);
- assertEquals(p.capacityChars(), 5);
- assertEquals(p.capacityComponents(), 1);
- assertEquals(p.toString('@'), "hello");
- p = new CategoryPath("hi/there", '/');
- assertEquals(p.length(), 2);
- assertEquals(p.capacityChars(), 7);
- assertEquals(p.capacityComponents(), 2);
- assertEquals(p.toString('@'), "hi@there");
- p = new CategoryPath("how/are/you/doing?", '/');
- assertEquals(p.length(), 4);
- assertEquals(p.capacityChars(), 15);
- assertEquals(p.capacityComponents(), 4);
- assertEquals(p.toString('@'), "how@are@you@doing?");
- }
-
- @Test
- public void testDefaultConstructor() {
- // test that the default constructor (no parameters) currently
- // defaults to creating an object with a 0 initial capacity.
- // If we change this default later, we also need to change this
- // test.
- CategoryPath p = new CategoryPath();
- assertEquals(0, p.capacityChars());
- assertEquals(0, p.capacityComponents());
- assertEquals(0, p.length());
- assertEquals("", p.toString('/'));
- }
-
- @Test
- public void testAddEmpty() {
- // In the current implementation, p.add("") should add en empty
- // component (which is, admitingly, not a useful case. On the other
- // hand, p.add("", delimiter) should add no components at all.
- // Verify this:
- CategoryPath p = new CategoryPath(0, 0);
- p.add("");
- assertEquals(1, p.length());
- p.add("");
- assertEquals(2, p.length());
- p.add("", '/');
- assertEquals(2, p.length());
- p.clear();
- p.add("", '/');
- assertEquals(0, p.length());
- }
-
- @Test
- public void testDelimiterAdd() {
- // Test that the add() that takes a string and a delimiter
- // works correctly. Note that unlike the constructor test above,
- // we can't expect the capacity to grow to exactly the length of
- // the given category, so we do not test this.
- CategoryPath p = new CategoryPath(0, 0);
- p.add("", '/');
- assertEquals(0, p.length());
- assertEquals("", p.toString('@'), "");
- p.clear();
- p.add("hello", '/');
- assertEquals(p.length(), 1);
- assertEquals(p.toString('@'), "hello");
- p.clear();
- p.add("hi/there", '/');
- assertEquals(p.length(), 2);
- assertEquals(p.toString('@'), "hi@there");
- p.clear();
- p.add("how/are/you/doing?", '/');
- assertEquals(p.length(), 4);
- assertEquals(p.toString('@'), "how@are@you@doing?");
- // See that this is really an add, not replace:
- p.clear();
- p.add("hi/there", '/');
- assertEquals(p.length(), 2);
- assertEquals(p.toString('@'), "hi@there");
- p.add("how/are/you/doing", '/');
- assertEquals(p.length(), 6);
- assertEquals(p.toString('@'), "hi@there@how@are@you@doing");
- }
-
- @Test
- public void testCopyConstructor() {
- CategoryPath p = new CategoryPath(0,0);
- int expectedchars=0;
- for (int i=0; i<1000; i++) {
- CategoryPath clone = new CategoryPath(p);
- assertEquals(p.length(), clone.length());
- assertEquals(p.toString('/'), clone.toString('/'));
- // verify that the newly created clone has exactly the right
- // capacity, with no spare (while the original path p probably
- // does have spare)
- assertEquals(i, clone.capacityComponents());
- assertEquals(expectedchars, clone.capacityChars());
- // Finally, add another component to the path, for the next
- // round of this loop
- String num = Integer.toString(i);
- p.add(num);
- expectedchars+=num.length();
- }
- }
-
- @Test
- public void testPrefixCopyConstructor() {
- CategoryPath p = new CategoryPath(0,0);
- p.add("hi");
- p.add("there");
- p.add("man");
- assertEquals(p.length(), 3);
-
- CategoryPath p1 = new CategoryPath(p,2);
- assertEquals(2, p1.length());
- assertEquals("hi/there", p1.toString('/'));
- // the new prefix object should only take the space it needs:
- assertEquals(2, p1.capacityComponents());
- assertEquals(7, p1.capacityChars());
-
- p1 = new CategoryPath(p,1);
- assertEquals(1, p1.length());
- assertEquals("hi", p1.toString('/'));
- assertEquals(1, p1.capacityComponents());
- assertEquals(2, p1.capacityChars());
-
- p1 = new CategoryPath(p,0);
- assertEquals(0, p1.length());
- assertEquals("", p1.toString('/'));
- assertEquals(0, p1.capacityComponents());
- assertEquals(0, p1.capacityChars());
-
- // with all the following lengths, the prefix should be the whole path:
- int[] lengths = { 3, -1, 4 };
- for (int i=0; i<lengths.length; i++) {
- p1 = new CategoryPath(p, lengths[i]);
- assertEquals(3, p1.length());
- assertEquals("hi/there/man", p1.toString('/'));
- assertEquals(p, p1);
- assertEquals(3, p1.capacityComponents());
- assertEquals(10, p1.capacityChars());
- }
- }
-
- @Test
- public void testEquals() {
- // check that two empty paths are equal, even if they have different
- // capacities:
- CategoryPath p1 = new CategoryPath(0,0);
- CategoryPath p2 = new CategoryPath(1000,300);
- assertEquals(true, p1.equals(p2));
- // If we make p2 different, it is no longer equals:
- p2.add("hi");
- assertEquals(false, p1.equals(p2));
- // A categoryPath is definitely not equals to an object of some other
- // type:
- assertEquals(false, p1.equals(Integer.valueOf(3)));
- // Build two paths separately, and compare them
- p1.clear();
- p1.add("hello");
- p1.add("world");
- p2.clear();
- p2.add("hello");
- p2.add("world");
- assertEquals(true, p1.equals(p2));
- // Check that comparison really don't look at old data which might
- // be stored in the array
- p1.clear();
- p1.add("averylongcategoryname");
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hi");
- assertEquals(true, p1.equals(p2));
- // Being of the same length is obviously not enough to be equal
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hello");
- assertEquals(false, p1.equals(p2));
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("ho");
- assertEquals(false, p1.equals(p2));
- }
- @Test
- public void testHashCode() {
- // Note: in this test, we assume that if two paths are not equal,
- // their hash codes should come out differently. This is *not*
- // always the case, but in the examples we use below, it comes out
- // fine, and unless we have some really bad luck in changing our
- // hash function, this should also remain true in the future.
-
- // check that two empty paths are equal, even if they have different
- // capacities:
- CategoryPath p1 = new CategoryPath(0,0);
- CategoryPath p2 = new CategoryPath(1000,300);
- assertEquals(p1.hashCode(), p2.hashCode());
- // If we make p2 different, it is no longer equals:
- p2.add("hi");
- assertEquals(false, p1.hashCode()==p2.hashCode());
- // Build two paths separately, and compare them
- p1.clear();
- p1.add("hello");
- p1.add("world");
- p2.clear();
- p2.add("hello");
- p2.add("world");
- assertEquals(p1.hashCode(), p2.hashCode());
- // Check that comparison really don't look at old data which might
- // be stored in the array
- p1.clear();
- p1.add("averylongcategoryname");
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hi");
- assertEquals(p1.hashCode(), p2.hashCode());
- // Being of the same length is obviously not enough to be equal
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hello");
- assertEquals(false, p1.hashCode()==p2.hashCode());
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("ho");
- assertEquals(false, p1.hashCode()==p2.hashCode());
- }
-
- @Test
- public void testHashCodePrefix() {
- // First, repeat the tests of testHashCode() using hashCode(-1)
- // just to make sure nothing was broken in this variant:
- CategoryPath p1 = new CategoryPath(0,0);
- CategoryPath p2 = new CategoryPath(1000,300);
- assertEquals(p1.hashCode(-1), p2.hashCode(-1));
- p2.add("hi");
- assertEquals(false, p1.hashCode(-1)==p2.hashCode(-1));
- p1.clear();
- p1.add("hello");
- p1.add("world");
- p2.clear();
- p2.add("hello");
- p2.add("world");
- assertEquals(p1.hashCode(-1), p2.hashCode(-1));
- p1.clear();
- p1.add("averylongcategoryname");
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hi");
- assertEquals(p1.hashCode(-1), p2.hashCode(-1));
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hello");
- assertEquals(false, p1.hashCode(-1)==p2.hashCode(-1));
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("ho");
- assertEquals(false, p1.hashCode(-1)==p2.hashCode(-1));
-
- // Now move to testing prefixes:
- CategoryPath p = new CategoryPath();
- p.add("this");
- p.add("is");
- p.add("a");
- p.add("test");
- assertEquals(p.hashCode(), p.hashCode(4));
- assertEquals(new CategoryPath().hashCode(), p.hashCode(0));
- assertEquals(new CategoryPath(p, 1).hashCode(), p.hashCode(1));
- assertEquals(new CategoryPath(p, 2).hashCode(), p.hashCode(2));
- assertEquals(new CategoryPath(p, 3).hashCode(), p.hashCode(3));
- }
-
- @Test
- public void testLongHashCode() {
- // Note: in this test, we assume that if two paths are not equal,
- // their hash codes should come out differently. This is *not*
- // always the case, but in the examples we use below, it comes out
- // fine, and unless we have some really bad luck in changing our
- // hash function, this should also remain true in the future.
-
- // check that two empty paths are equal, even if they have different
- // capacities:
- CategoryPath p1 = new CategoryPath(0,0);
- CategoryPath p2 = new CategoryPath(1000,300);
- assertEquals(p1.longHashCode(), p2.longHashCode());
- // If we make p2 different, it is no longer equals:
- p2.add("hi");
- assertEquals(false, p1.longHashCode()==p2.longHashCode());
- // Build two paths separately, and compare them
- p1.clear();
- p1.add("hello");
- p1.add("world");
- p2.clear();
- p2.add("hello");
- p2.add("world");
- assertEquals(p1.longHashCode(), p2.longHashCode());
- // Check that comparison really don't look at old data which might
- // be stored in the array
- p1.clear();
- p1.add("averylongcategoryname");
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hi");
- assertEquals(p1.longHashCode(), p2.longHashCode());
- // Being of the same length is obviously not enough to be equal
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hello");
- assertEquals(false, p1.longHashCode()==p2.longHashCode());
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("ho");
- assertEquals(false, p1.longHashCode()==p2.longHashCode());
- }
-
- @Test
- public void testLongHashCodePrefix() {
- // First, repeat the tests of testLongHashCode() using longHashCode(-1)
- // just to make sure nothing was broken in this variant:
-
- // check that two empty paths are equal, even if they have different
- // capacities:
- CategoryPath p1 = new CategoryPath(0,0);
- CategoryPath p2 = new CategoryPath(1000,300);
- assertEquals(p1.longHashCode(-1), p2.longHashCode(-1));
- // If we make p2 different, it is no longer equals:
- p2.add("hi");
- assertEquals(false, p1.longHashCode(-1)==p2.longHashCode(-1));
- // Build two paths separately, and compare them
- p1.clear();
- p1.add("hello");
- p1.add("world");
- p2.clear();
- p2.add("hello");
- p2.add("world");
- assertEquals(p1.longHashCode(-1), p2.longHashCode(-1));
- // Check that comparison really don't look at old data which might
- // be stored in the array
- p1.clear();
- p1.add("averylongcategoryname");
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hi");
- assertEquals(p1.longHashCode(-1), p2.longHashCode(-1));
- // Being of the same length is obviously not enough to be equal
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("hello");
- assertEquals(false, p1.longHashCode(-1)==p2.longHashCode(-1));
- p1.clear();
- p1.add("hi");
- p2.clear();
- p2.add("ho");
- assertEquals(false, p1.longHashCode(-1)==p2.longHashCode(-1));
-
- // Now move to testing prefixes:
- CategoryPath p = new CategoryPath();
- p.add("this");
- p.add("is");
- p.add("a");
- p.add("test");
- assertEquals(p.longHashCode(), p.longHashCode(4));
- assertEquals(new CategoryPath().longHashCode(), p.longHashCode(0));
- assertEquals(new CategoryPath(p, 1).longHashCode(), p.longHashCode(1));
- assertEquals(new CategoryPath(p, 2).longHashCode(), p.longHashCode(2));
- assertEquals(new CategoryPath(p, 3).longHashCode(), p.longHashCode(3));
- }
-
- @Test
- public void testArrayConstructor() {
- CategoryPath p = new CategoryPath("hello", "world", "yo");
- assertEquals(3, p.length());
- assertEquals(12, p.capacityChars());
- assertEquals(3, p.capacityComponents());
- assertEquals("hello/world/yo", p.toString('/'));
-
- p = new CategoryPath(new String[0]);
- assertEquals(0, p.length());
- assertEquals(0, p.capacityChars());
- assertEquals(0, p.capacityComponents());
- }
-
- @Test
- public void testCharsNeededForFullPath() {
- String[] components = { "hello", "world", "yo" };
- CategoryPath p = new CategoryPath();
- assertEquals(0, p.charsNeededForFullPath());
- int expectedCharsNeeded = 0;
- for (int i=0; i<components.length; i++) {
- p.add(components[i]);
- expectedCharsNeeded += components[i].length();
- if (i>0) {
- expectedCharsNeeded++;
- }
- assertEquals(expectedCharsNeeded, p.charsNeededForFullPath());
- }
- }
-
- @Test
- public void testCopyToCharArray() {
- String[] components = { "hello", "world", "yo" };
- CategoryPath p = new CategoryPath(components);
- char[] charArray = new char[p.charsNeededForFullPath()];
- int numCharsCopied = 0;
-
- numCharsCopied = p.copyToCharArray(charArray, 0, 0, '.');
- assertEquals(0, numCharsCopied);
- assertEquals("", new String(charArray, 0, numCharsCopied));
-
- numCharsCopied = p.copyToCharArray(charArray, 0, 1, '.');
- assertEquals(5, numCharsCopied);
- assertEquals("hello", new String(charArray, 0, numCharsCopied));
-
- numCharsCopied = p.copyToCharArray(charArray, 0, 3, '.');
- assertEquals(14, numCharsCopied);
- assertEquals("hello.world.yo", new String(charArray, 0, numCharsCopied));
-
- numCharsCopied = p.copyToCharArray(charArray, 0, -1, '.');
- assertEquals(14, numCharsCopied);
- assertEquals("hello.world.yo", new String(charArray, 0, numCharsCopied));
- numCharsCopied = p.copyToCharArray(charArray, 0, 4, '.');
- assertEquals(14, numCharsCopied);
- assertEquals("hello.world.yo", new String(charArray, 0, numCharsCopied));
- }
-
- @Test
- public void testCharSerialization() throws Exception {
- CategoryPath[] testCategories = {
- new CategoryPath("hi", "there", "man"),
- new CategoryPath("hello"),
- new CategoryPath("what's", "up"),
- // See that an empty category, which generates a (char)0,
- // doesn't cause any problems in the middle of the serialization:
- new CategoryPath(),
- new CategoryPath("another", "example"),
- new CategoryPath(),
- new CategoryPath()
- };
- StringBuilder sb = new StringBuilder();
- for (int i=0; i<testCategories.length; i++) {
- testCategories[i].serializeAppendTo(sb);
- }
-
- CategoryPath tmp = new CategoryPath();
- int offset=0;
- for (int i=0; i<testCategories.length; i++) {
- // check equalsToSerialized, in a equal and non-equal case:
- assertTrue(testCategories[i].equalsToSerialized(sb, offset));
- assertFalse(new CategoryPath("Hello", "world").equalsToSerialized(sb, offset));
- assertFalse(new CategoryPath("world").equalsToSerialized(sb, offset));
- // and check hashCodeFromSerialized:
- assertEquals(testCategories[i].hashCode(), CategoryPath.hashCodeOfSerialized(sb, offset));
- // and check setFromSerialized:
- offset = tmp.setFromSerialized(sb, offset);
- assertEquals(testCategories[i], tmp);
- }
- assertEquals(offset, sb.length());
- // A similar test, for a much longer path (though not larger than the
- // 2^15-1 character limit that CategoryPath allows:
- sb = new StringBuilder();
- CategoryPath p = new CategoryPath();
- for (int i=0; i<1000; i++) {
- p.add(Integer.toString(i));
- }
- p.serializeAppendTo(sb);
- p.serializeAppendTo(sb);
- p.serializeAppendTo(sb);
- offset=0;
- assertTrue(p.equalsToSerialized(sb, offset));
- assertEquals(p.hashCode(), CategoryPath.hashCodeOfSerialized(sb, offset));
- offset = tmp.setFromSerialized(sb, offset);
- assertEquals(p, tmp);
- assertTrue(p.equalsToSerialized(sb, offset));
- assertEquals(p.hashCode(), CategoryPath.hashCodeOfSerialized(sb, offset));
- offset = tmp.setFromSerialized(sb, offset);
- assertEquals(p, tmp);
- assertTrue(p.equalsToSerialized(sb, offset));
- assertEquals(p.hashCode(), CategoryPath.hashCodeOfSerialized(sb, offset));
- offset = tmp.setFromSerialized(sb, offset);
- assertEquals(p, tmp);
- assertEquals(offset, sb.length());
-
- // Test the serializeAppendTo variant with a prefixLen
- p = new CategoryPath();
- for (int i=0; i<783; i++) {
- p.add(Integer.toString(i));
- }
- int[] prefixLengths = { 0, 574, 782, 783, 784, -1 };
- for (int prefixLen : prefixLengths) {
- sb = new StringBuilder();
- p.serializeAppendTo(prefixLen, sb);
- assertTrue(new CategoryPath(p, prefixLen).equalsToSerialized(sb, 0));
- }
-
- // Test the equalsToSerialized variant with a prefixLen
- // We use p and prefixLengths set above.
- for (int prefixLen : prefixLengths) {
- sb = new StringBuilder();
- new CategoryPath(p, prefixLen).serializeAppendTo(sb);
- assertTrue(p.equalsToSerialized(prefixLen, sb, 0));
- }
-
- // Check also the false case of equalsToSerialized with prefixLen:
- sb = new StringBuilder();
- new CategoryPath().serializeAppendTo(sb);
- assertTrue(new CategoryPath().equalsToSerialized(0, sb, 0));
- assertTrue(new CategoryPath("a", "b").equalsToSerialized(0, sb, 0));
- assertFalse(new CategoryPath("a", "b").equalsToSerialized(1, sb, 0));
- sb = new StringBuilder();
- new CategoryPath("a", "b").serializeAppendTo(sb);
- assertFalse(new CategoryPath().equalsToSerialized(0, sb, 0));
- assertFalse(new CategoryPath("a").equalsToSerialized(0, sb, 0));
- assertFalse(new CategoryPath("a").equalsToSerialized(1, sb, 0));
- assertFalse(new CategoryPath("a", "b").equalsToSerialized(0, sb, 0));
- assertFalse(new CategoryPath("a", "b").equalsToSerialized(1, sb, 0));
- assertTrue(new CategoryPath("a", "b").equalsToSerialized(2, sb, 0));
- assertTrue(new CategoryPath("a", "b", "c").equalsToSerialized(2, sb, 0));
- assertFalse(new CategoryPath("z", "b", "c").equalsToSerialized(2, sb, 0));
- assertFalse(new CategoryPath("aa", "b", "c").equalsToSerialized(2, sb, 0));
- }
-
- @Test
- public void testStreamWriterSerialization() throws Exception {
- CategoryPath[] testPaths = {
- new CategoryPath("hi", "there", "man"),
- new CategoryPath("hello"),
- new CategoryPath("date", "2009", "May", "13", "14", "59", "00"),
- // See that an empty category, which generates a (char)0,
- // doesn't cause any problems in the middle of the serialization:
- new CategoryPath(),
- new CategoryPath("another", "example")
- };
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- OutputStreamWriter osw = new OutputStreamWriter(baos, "UTF-8"); // UTF-8 is always supported.
- for (CategoryPath cp : testPaths) {
- cp.serializeToStreamWriter(osw);
- }
- osw.flush();
- ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
- InputStreamReader isr = new InputStreamReader(bais, "UTF-8");
- CategoryPath[] checkPaths = {
- new CategoryPath(), new CategoryPath(), new CategoryPath(), new CategoryPath(), new CategoryPath()
- };
- for (int j = 0; j < checkPaths.length; j++) {
- checkPaths[j].deserializeFromStreamReader(isr);
- assertEquals("Paths not equal", testPaths[j], checkPaths[j]);
- }
- }
-
- @Test
- public void testCharSequenceCtor() throws Exception {
- CategoryPath[] testPaths = {
- new CategoryPath(new CS("hi"), new CS("there"), new CS("man")),
- new CategoryPath(new CS("hello")),
- new CategoryPath(new CS("date"), new CS("2009"), new CS("May"), new CS("13"),
- new CS("14"), new CS("59"), new CS("00")),
- new CategoryPath(),
- new CategoryPath(new CS("another"), new CS("example"))
- };
- assertEquals("Wrong capacity", 10, testPaths[0].capacityChars());
- assertEquals("Wrong capacity", 5, testPaths[1].capacityChars());
- assertEquals("Wrong capacity", 19, testPaths[2].capacityChars());
- assertEquals("Wrong capacity", 0, testPaths[3].capacityChars());
- assertEquals("Wrong capacity", 14, testPaths[4].capacityChars());
-
- assertEquals("Wrong component", "hi", testPaths[0].getComponent(0));
- assertEquals("Wrong component", "there", testPaths[0].getComponent(1));
- assertEquals("Wrong component", "man", testPaths[0].getComponent(2));
- assertEquals("Wrong component", "hello", testPaths[1].getComponent(0));
- assertEquals("Wrong component", "date", testPaths[2].getComponent(0));
- assertEquals("Wrong component", "2009", testPaths[2].getComponent(1));
- assertEquals("Wrong component", "May", testPaths[2].getComponent(2));
- assertEquals("Wrong component", "13", testPaths[2].getComponent(3));
- assertEquals("Wrong component", "14", testPaths[2].getComponent(4));
- assertEquals("Wrong component", "59", testPaths[2].getComponent(5));
- assertEquals("Wrong component", "00", testPaths[2].getComponent(6));
- assertNull("Not null component", testPaths[3].getComponent(0));
- assertEquals("Wrong component", "another", testPaths[4].getComponent(0));
- assertEquals("Wrong component", "example", testPaths[4].getComponent(1));
- }
-
- @Test
- public void testIsDescendantOf() throws Exception {
- CategoryPath[] testPaths = {
- new CategoryPath(new CS("hi"), new CS("there")),
- new CategoryPath(new CS("hi"), new CS("there"), new CS("man")),
- new CategoryPath(new CS("hithere"), new CS("man")),
- new CategoryPath(new CS("hi"), new CS("there"), new CS("mano")),
- new CategoryPath(),
- };
- assertTrue(testPaths[0].isDescendantOf(testPaths[0]));
- assertTrue(testPaths[0].isDescendantOf(testPaths[4]));
- assertFalse(testPaths[4].isDescendantOf(testPaths[0]));
- assertTrue(testPaths[1].isDescendantOf(testPaths[0]));
- assertTrue(testPaths[1].isDescendantOf(testPaths[1]));
- assertTrue(testPaths[3].isDescendantOf(testPaths[0]));
- assertFalse(testPaths[2].isDescendantOf(testPaths[0]));
- assertFalse(testPaths[2].isDescendantOf(testPaths[1]));
- assertFalse(testPaths[3].isDescendantOf(testPaths[1]));
- }
-
- @Test
- public void testCompareTo() {
- CategoryPath p = new CategoryPath("a/b/c/d", '/');
- CategoryPath pother = new CategoryPath("a/b/c/d", '/');
- assertTrue(pother.compareTo(p) == 0);
- pother = new CategoryPath("", '/');
- assertTrue(pother.compareTo(p) < 0);
- pother = new CategoryPath("a/b_/c/d", '/');
- assertTrue(pother.compareTo(p) > 0);
- pother = new CategoryPath("a/b/c", '/');
- assertTrue(pother.compareTo(p) < 0);
- pother = new CategoryPath("a/b/c/e", '/');
- assertTrue(pother.compareTo(p) > 0);
- pother = new CategoryPath("a/b/c//e", '/');
- assertTrue(pother.compareTo(p) < 0);
- }
-
- private static class CS implements CharSequence {
- public CS(String s) {
- this.ca = new char[s.length()];
- s.getChars(0, s.length(), this.ca, 0);
- }
- public char charAt(int index) {
- return this.ca[index];
- }
- public int length() {
- return this.ca.length;
- }
- public CharSequence subSequence(int start, int end) {
- return null; // not used.
- }
- private char[] ca;
- }
-
-}
fnp / pylucene.git / blobdiff