X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.4.0/lucene/contrib/facet/src/test/org/apache/lucene/facet/taxonomy/TestCategoryPath.java

diff --git a/lucene-java-3.4.0/lucene/contrib/facet/src/test/org/apache/lucene/facet/taxonomy/TestCategoryPath.java b/lucene-java-3.4.0/lucene/contrib/facet/src/test/org/apache/lucene/facet/taxonomy/TestCategoryPath.java
deleted file mode 100644
index 784c07c..0000000
--- a/lucene-java-3.4.0/lucene/contrib/facet/src/test/org/apache/lucene/facet/taxonomy/TestCategoryPath.java
+++ /dev/null
@@ -1,901 +0,0 @@
-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;
-  }
-
-}