lucene-java-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mikemcc...@apache.org
Subject svn commit: r738219 [3/3] - in /lucene/java/trunk: ./ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ contrib/miscellaneous/src/test/org/apache/lucene/index/ cont...
Date Tue, 27 Jan 2009 20:15:23 GMT
Modified: lucene/java/trunk/src/test/org/apache/lucene/search/TestSort.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/src/test/org/apache/lucene/search/TestSort.java?rev=738219&r1=738218&r2=738219&view=diff
==============================================================================
--- lucene/java/trunk/src/test/org/apache/lucene/search/TestSort.java (original)
+++ lucene/java/trunk/src/test/org/apache/lucene/search/TestSort.java Tue Jan 27 20:15:21 2009
@@ -18,27 +18,30 @@
  */
 
 import junit.framework.Test;
-import junit.framework.TestCase;
 import junit.framework.TestSuite;
 import junit.textui.TestRunner;
 import org.apache.lucene.analysis.SimpleAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
+import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.Term;
+import org.apache.lucene.queryParser.ParseException;
+import org.apache.lucene.store.LockObtainFailedException;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.util.DocIdBitSet;
+import org.apache.lucene.util.LuceneTestCase;
 
 import java.io.IOException;
 import java.io.Serializable;
 import java.rmi.Naming;
 import java.rmi.registry.LocateRegistry;
-import java.rmi.registry.Registry;
 import java.util.BitSet;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Locale;
+import java.util.Random;
 import java.util.regex.Pattern;
 
 /**
@@ -51,472 +54,640 @@
  */
 
 public class TestSort
-extends TestCase
+extends LuceneTestCase
 implements Serializable {
 
-	private Searcher full;
-	private Searcher searchX;
-	private Searcher searchY;
-	private Query queryX;
-	private Query queryY;
-	private Query queryA;
-	private Query queryE;
-	private Query queryF;
-	private Query queryG;
-	private Sort sort;
-
-
-	public TestSort (String name) {
-		super (name);
-	}
-
-	public static void main (String[] argv) {
-		if (argv == null || argv.length < 1)
-			TestRunner.run (suite());
-		else if ("server".equals (argv[0])) {
-			TestSort test = new TestSort (null);
-			try {
-				test.startServer();
-				Thread.sleep (500000);
-			} catch (Exception e) {
-				System.out.println (e);
-				e.printStackTrace();
-			}
-		}
-	}
-
-	public static Test suite() {
-		return new TestSuite (TestSort.class);
-	}
-
-
-	// document data:
-	// the tracer field is used to determine which document was hit
-	// the contents field is used to search and sort by relevance
-	// the int field to sort by int
-	// the float field to sort by float
-	// the string field to sort by string
+  private static final int NUM_STRINGS = 6000;
+  private Searcher full;
+  private Searcher searchX;
+  private Searcher searchY;
+  private Query queryX;
+  private Query queryY;
+  private Query queryA;
+  private Query queryE;
+  private Query queryF;
+  private Query queryG;
+  private Sort sort;
+
+
+  public TestSort (String name) {
+    super (name);
+  }
+
+  public static void main (String[] argv) {
+    if (argv == null || argv.length < 1)
+      TestRunner.run (suite());
+    else if ("server".equals (argv[0])) {
+      TestSort test = new TestSort (null);
+      try {
+        test.startServer();
+        Thread.sleep (500000);
+      } catch (Exception e) {
+        System.out.println (e);
+        e.printStackTrace();
+      }
+    }
+  }
+
+  public static Test suite() {
+    return new TestSuite (TestSort.class);
+  }
+
+
+  // document data:
+  // the tracer field is used to determine which document was hit
+  // the contents field is used to search and sort by relevance
+  // the int field to sort by int
+  // the float field to sort by float
+  // the string field to sort by string
     // the i18n field includes accented characters for testing locale-specific sorting
-	private String[][] data = new String[][] {
-	// tracer  contents         int            float           string   custom   i18n               long            double, 'short', byte, 'custom parser encoding'
-	{   "A",   "x a",           "5",           "4f",           "c",     "A-3",   "p\u00EAche",      "10",           "-4.0", "3", "126", "J"},//A, x
-	{   "B",   "y a",           "5",           "3.4028235E38", "i",     "B-10",  "HAT",             "1000000000", "40.0", "24", "1", "I"},//B, y
-	{   "C",   "x a b c",       "2147483647",  "1.0",          "j",     "A-2",   "p\u00E9ch\u00E9", "99999999",   "40.00002343", "125", "15", "H"},//C, x
-	{   "D",   "y a b c",       "-1",          "0.0f",         "a",     "C-0",   "HUT",             String.valueOf(Long.MAX_VALUE),           String.valueOf(Double.MIN_VALUE), String.valueOf(Short.MIN_VALUE), String.valueOf(Byte.MIN_VALUE), "G"},//D, y
-	{   "E",   "x a b c d",     "5",           "2f",           "h",     "B-8",   "peach",           String.valueOf(Long.MIN_VALUE),           String.valueOf(Double.MAX_VALUE), String.valueOf(Short.MAX_VALUE),           String.valueOf(Byte.MAX_VALUE), "F"},//E,x
-	{   "F",   "y a b c d",     "2",           "3.14159f",     "g",     "B-1",   "H\u00C5T",        "-44",           "343.034435444", "-3", "0", "E"},//F,y
-	{   "G",   "x a b c d",     "3",           "-1.0",         "f",     "C-100", "sin",             "323254543543", "4.043544", "5", "100", "D"},//G,x
+  private String[][] data = new String[][] {
+  // tracer  contents         int            float           string   custom   i18n               long            double, 'short', byte, 'custom parser encoding'
+  {   "A",   "x a",           "5",           "4f",           "c",     "A-3",   "p\u00EAche",      "10",           "-4.0", "3", "126", "J"},//A, x
+  {   "B",   "y a",           "5",           "3.4028235E38", "i",     "B-10",  "HAT",             "1000000000", "40.0", "24", "1", "I"},//B, y
+  {   "C",   "x a b c",       "2147483647",  "1.0",          "j",     "A-2",   "p\u00E9ch\u00E9", "99999999",   "40.00002343", "125", "15", "H"},//C, x
+  {   "D",   "y a b c",       "-1",          "0.0f",         "a",     "C-0",   "HUT",             String.valueOf(Long.MAX_VALUE),           String.valueOf(Double.MIN_VALUE), String.valueOf(Short.MIN_VALUE), String.valueOf(Byte.MIN_VALUE), "G"},//D, y
+  {   "E",   "x a b c d",     "5",           "2f",           "h",     "B-8",   "peach",           String.valueOf(Long.MIN_VALUE),           String.valueOf(Double.MAX_VALUE), String.valueOf(Short.MAX_VALUE),           String.valueOf(Byte.MAX_VALUE), "F"},//E,x
+  {   "F",   "y a b c d",     "2",           "3.14159f",     "g",     "B-1",   "H\u00C5T",        "-44",           "343.034435444", "-3", "0", "E"},//F,y
+  {   "G",   "x a b c d",     "3",           "-1.0",         "f",     "C-100", "sin",             "323254543543", "4.043544", "5", "100", "D"},//G,x
   {   "H",   "y a b c d",     "0",           "1.4E-45",      "e",     "C-88",  "H\u00D8T",        "1023423423005","4.043545", "10", "-50", "C"},//H,y
-	{   "I",   "x a b c d e f", "-2147483648", "1.0e+0",       "d",     "A-10",  "s\u00EDn",        "332422459999", "4.043546", "-340", "51", "B"},//I,x
-	{   "J",   "y a b c d e f", "4",           ".5",           "b",     "C-7",   "HOT",             "34334543543",  "4.0000220343", "300", "2", "A"},//J,y
-	{   "W",   "g",             "1",           null,           null,    null,    null,              null,           null, null, null, null},
-	{   "X",   "g",             "1",           "0.1",          null,    null,    null,              null,           null, null, null, null},
-	{   "Y",   "g",             "1",           "0.2",          null,    null,    null,              null,           null, null, null, null},
-	{   "Z",   "f g",           null,          null,           null,    null,    null,              null,           null, null, null, null}
- 	};
-
-	// create an index of all the documents, or just the x, or just the y documents
-	private Searcher getIndex (boolean even, boolean odd)
-	throws IOException {
-		RAMDirectory indexStore = new RAMDirectory ();
-		IndexWriter writer = new IndexWriter (indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
-		for (int i=0; i<data.length; ++i) {
-			if (((i%2)==0 && even) || ((i%2)==1 && odd)) {
-				Document doc = new Document();
-				doc.add (new Field ("tracer",   data[i][0], Field.Store.YES, Field.Index.NO));
-				doc.add (new Field ("contents", data[i][1], Field.Store.NO, Field.Index.ANALYZED));
-				if (data[i][2] != null) doc.add (new Field ("int",      data[i][2], Field.Store.NO, Field.Index.NOT_ANALYZED));
-				if (data[i][3] != null) doc.add (new Field ("float",    data[i][3], Field.Store.NO, Field.Index.NOT_ANALYZED));
-				if (data[i][4] != null) doc.add (new Field ("string",   data[i][4], Field.Store.NO, Field.Index.NOT_ANALYZED));
-				if (data[i][5] != null) doc.add (new Field ("custom",   data[i][5], Field.Store.NO, Field.Index.NOT_ANALYZED));
-				if (data[i][6] != null) doc.add (new Field ("i18n",     data[i][6], Field.Store.NO, Field.Index.NOT_ANALYZED));
+  {   "I",   "x a b c d e f", "-2147483648", "1.0e+0",       "d",     "A-10",  "s\u00EDn",        "332422459999", "4.043546", "-340", "51", "B"},//I,x
+  {   "J",   "y a b c d e f", "4",           ".5",           "b",     "C-7",   "HOT",             "34334543543",  "4.0000220343", "300", "2", "A"},//J,y
+  {   "W",   "g",             "1",           null,           null,    null,    null,              null,           null, null, null, null},
+  {   "X",   "g",             "1",           "0.1",          null,    null,    null,              null,           null, null, null, null},
+  {   "Y",   "g",             "1",           "0.2",          null,    null,    null,              null,           null, null, null, null},
+  {   "Z",   "f g",           null,          null,           null,    null,    null,              null,           null, null, null, null}
+  };
+
+  // create an index of all the documents, or just the x, or just the y documents
+  private Searcher getIndex (boolean even, boolean odd)
+  throws IOException {
+    RAMDirectory indexStore = new RAMDirectory ();
+    IndexWriter writer = new IndexWriter (indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
+    writer.setMaxBufferedDocs(2);
+    writer.setMergeFactor(1000);
+    for (int i=0; i<data.length; ++i) {
+      if (((i%2)==0 && even) || ((i%2)==1 && odd)) {
+        Document doc = new Document();
+        doc.add (new Field ("tracer",   data[i][0], Field.Store.YES, Field.Index.NO));
+        doc.add (new Field ("contents", data[i][1], Field.Store.NO, Field.Index.ANALYZED));
+        if (data[i][2] != null) doc.add (new Field ("int",      data[i][2], Field.Store.NO, Field.Index.NOT_ANALYZED));
+        if (data[i][3] != null) doc.add (new Field ("float",    data[i][3], Field.Store.NO, Field.Index.NOT_ANALYZED));
+        if (data[i][4] != null) doc.add (new Field ("string",   data[i][4], Field.Store.NO, Field.Index.NOT_ANALYZED));
+        if (data[i][5] != null) doc.add (new Field ("custom",   data[i][5], Field.Store.NO, Field.Index.NOT_ANALYZED));
+        if (data[i][6] != null) doc.add (new Field ("i18n",     data[i][6], Field.Store.NO, Field.Index.NOT_ANALYZED));
         if (data[i][7] != null) doc.add (new Field ("long",     data[i][7], Field.Store.NO, Field.Index.NOT_ANALYZED));
         if (data[i][8] != null) doc.add (new Field ("double",     data[i][8], Field.Store.NO, Field.Index.NOT_ANALYZED));
         if (data[i][9] != null) doc.add (new Field ("short",     data[i][9], Field.Store.NO, Field.Index.NOT_ANALYZED));
         if (data[i][10] != null) doc.add (new Field ("byte",     data[i][10], Field.Store.NO, Field.Index.NOT_ANALYZED));
         if (data[i][11] != null) doc.add (new Field ("parser",     data[i][11], Field.Store.NO, Field.Index.NOT_ANALYZED));
         doc.setBoost(2);  // produce some scores above 1.0
-				writer.addDocument (doc);
-			}
-		}
-		writer.optimize ();
-		writer.close ();
-		return new IndexSearcher (indexStore);
-	}
-
-	private Searcher getFullIndex()
-	throws IOException {
-		return getIndex (true, true);
-	}
-
-	private Searcher getXIndex()
-	throws IOException {
-		return getIndex (true, false);
-	}
-
-	private Searcher getYIndex()
-	throws IOException {
-		return getIndex (false, true);
-	}
-
-	private Searcher getEmptyIndex()
-	throws IOException {
-		return getIndex (false, false);
-	}
-
-	public void setUp() throws Exception {
-		full = getFullIndex();
-		searchX = getXIndex();
-		searchY = getYIndex();
-		queryX = new TermQuery (new Term ("contents", "x"));
-		queryY = new TermQuery (new Term ("contents", "y"));
-		queryA = new TermQuery (new Term ("contents", "a"));
+        writer.addDocument (doc);
+      }
+    }
+    //writer.optimize ();
+    writer.close ();
+    return new IndexSearcher (indexStore);
+  }
+
+  private Searcher getFullIndex()
+  throws IOException {
+    return getIndex (true, true);
+  }
+  
+  private IndexSearcher getFullStrings() throws CorruptIndexException, LockObtainFailedException, IOException {
+    RAMDirectory indexStore = new RAMDirectory ();
+    IndexWriter writer = new IndexWriter (indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
+    writer.setMaxBufferedDocs(4);
+    writer.setMergeFactor(97);
+    for (int i=0; i<NUM_STRINGS; i++) {
+        Document doc = new Document();
+        String num = getRandomCharString(getRandomNumber(2, 8), 48, 52);
+        doc.add (new Field ("tracer", num, Field.Store.YES, Field.Index.NO));
+        //doc.add (new Field ("contents", Integer.toString(i), Field.Store.NO, Field.Index.ANALYZED));
+        doc.add (new Field ("string", num, Field.Store.NO, Field.Index.NOT_ANALYZED));
+        String num2 = getRandomCharString(getRandomNumber(1, 4), 48, 50);
+        doc.add (new Field ("string2", num2, Field.Store.NO, Field.Index.NOT_ANALYZED));
+        doc.add (new Field ("tracer2", num2, Field.Store.YES, Field.Index.NO));
+        doc.setBoost(2);  // produce some scores above 1.0
+        writer.setMaxBufferedDocs(getRandomNumber(2, 12));
+        writer.addDocument (doc);
+      
+    }
+    //writer.optimize ();
+    //System.out.println(writer.getSegmentCount());
+    writer.close ();
+    return new IndexSearcher (indexStore);
+  }
+  
+  public static String getRandomNumberString(int num, int low, int high) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < num; i++) {
+      sb.append(getRandomNumber(low, high));
+    }
+    return sb.toString();
+  }
+  
+  public static String getRandomCharString(int num) {
+    return getRandomCharString(num, 48, 122);
+  }
+  
+  public static String getRandomCharString(int num, int start, int end) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < num; i++) {
+      sb.append(new Character((char) getRandomNumber(start, end)));
+    }
+    return sb.toString();
+  }
+  
+  static Random r = new Random();
+  
+  public static int getRandomNumber(final int low, final int high) {
+  
+    int randInt = (Math.abs(r.nextInt()) % (high - low)) + low;
+
+    return randInt;
+  }
+
+  private Searcher getXIndex()
+  throws IOException {
+    return getIndex (true, false);
+  }
+
+  private Searcher getYIndex()
+  throws IOException {
+    return getIndex (false, true);
+  }
+
+  private Searcher getEmptyIndex()
+  throws IOException {
+    return getIndex (false, false);
+  }
+
+  public void setUp() throws Exception {
+    super.setUp();
+    full = getFullIndex();
+    searchX = getXIndex();
+    searchY = getYIndex();
+    queryX = new TermQuery (new Term ("contents", "x"));
+    queryY = new TermQuery (new Term ("contents", "y"));
+    queryA = new TermQuery (new Term ("contents", "a"));
     queryE = new TermQuery (new Term ("contents", "e"));
-		queryF = new TermQuery (new Term ("contents", "f"));
-		queryG = new TermQuery (new Term ("contents", "g"));
-		sort = new Sort();
-	}
-
-	// test the sorts by score and document number
-	public void testBuiltInSorts() throws Exception {
-		sort = new Sort();
-		assertMatches (full, queryX, sort, "ACEGI");
-		assertMatches (full, queryY, sort, "BDFHJ");
-
-		sort.setSort(SortField.FIELD_DOC);
-		assertMatches (full, queryX, sort, "ACEGI");
-		assertMatches (full, queryY, sort, "BDFHJ");
-	}
-
-	// test sorts where the type of field is specified
-	public void testTypedSort() throws Exception {
-		sort.setSort (new SortField[] { new SortField ("int", SortField.INT), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "IGAEC");
-		assertMatches (full, queryY, sort, "DHFJB");
-
-		sort.setSort (new SortField[] { new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "GCIEA");
-		assertMatches (full, queryY, sort, "DHJFB");
+    queryF = new TermQuery (new Term ("contents", "f"));
+    queryG = new TermQuery (new Term ("contents", "g"));
+    sort = new Sort();
+  }
+
+  // test the sorts by score and document number
+  public void testBuiltInSorts() throws Exception {
+    sort = new Sort();
+    assertMatches (full, queryX, sort, "ACEGI");
+    assertMatches (full, queryY, sort, "BDFHJ");
+
+    sort.setSort(SortField.FIELD_DOC);
+    assertMatches (full, queryX, sort, "ACEGI");
+    assertMatches (full, queryY, sort, "BDFHJ");
+  }
+
+  // test sorts where the type of field is specified
+  public void testTypedSort() throws Exception {
+    sort.setSort (new SortField[] { new SortField ("int", SortField.INT), SortField.FIELD_DOC });
+    assertMatches (full, queryX, sort, "IGAEC");
+    assertMatches (full, queryY, sort, "DHFJB");
+
+    sort.setSort (new SortField[] { new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC });
+    assertMatches (full, queryX, sort, "GCIEA");
+    assertMatches (full, queryY, sort, "DHJFB");
 
     sort.setSort (new SortField[] { new SortField ("long", SortField.LONG), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "EACGI");
-		assertMatches (full, queryY, sort, "FBJHD");
+    assertMatches (full, queryX, sort, "EACGI");
+    assertMatches (full, queryY, sort, "FBJHD");
 
     sort.setSort (new SortField[] { new SortField ("double", SortField.DOUBLE), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "AGICE");
-		assertMatches (full, queryY, sort, "DJHBF");
+    assertMatches (full, queryX, sort, "AGICE");
+    assertMatches (full, queryY, sort, "DJHBF");
 
     sort.setSort (new SortField[] { new SortField ("byte", SortField.BYTE), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "CIGAE");
-		assertMatches (full, queryY, sort, "DHFBJ");
+    assertMatches (full, queryX, sort, "CIGAE");
+    assertMatches (full, queryY, sort, "DHFBJ");
 
     sort.setSort (new SortField[] { new SortField ("short", SortField.SHORT), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "IAGCE");
-		assertMatches (full, queryY, sort, "DFHBJ");
+    assertMatches (full, queryX, sort, "IAGCE");
+    assertMatches (full, queryY, sort, "DFHBJ");
 
     sort.setSort (new SortField[] { new SortField ("string", SortField.STRING), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "AIGEC");
-		assertMatches (full, queryY, sort, "DJHFB");
-	}
-
-	// test sorts where the type of field is specified and a custom field parser is used, that
-	// uses a simple char encoding. The sorted string contains a character beginning from 'A' that
-	// is mapped to a numeric value using some "funny" algorithm to be different for each data type.
-	public void testCustomFieldParserSort() throws Exception {
-		sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.IntParser(){
-			public final int parseInt(final String val) {
-				return (int) (val.charAt(0)-'A') * 123456;
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-
-		sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.FloatParser(){
-			public final float parseFloat(final String val) {
-				return (float) Math.sqrt( (double) val.charAt(0) );
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-
-		sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.LongParser(){
-			public final long parseLong(final String val) {
-				return (long) (val.charAt(0)-'A') * 1234567890L;
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-
-		sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.DoubleParser(){
-			public final double parseDouble(final String val) {
-				return Math.pow( (double) val.charAt(0), (double) (val.charAt(0)-'A') );
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-
-		sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.ByteParser(){
-			public final byte parseByte(final String val) {
-				return (byte) (val.charAt(0)-'A');
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-
-		sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.ShortParser(){
-			public final short parseShort(final String val) {
-				return (short) (val.charAt(0)-'A');
-			}
-		}), SortField.FIELD_DOC });
-		assertMatches (full, queryA, sort, "JIHGFEDCBA");
-	}
-
-	// test sorts when there's nothing in the index
-	public void testEmptyIndex() throws Exception {
-		Searcher empty = getEmptyIndex();
-
-		sort = new Sort();
-		assertMatches (empty, queryX, sort, "");
-
-		sort.setSort(SortField.FIELD_DOC);
-		assertMatches (empty, queryX, sort, "");
-
-		sort.setSort (new SortField[] { new SortField ("int", SortField.INT), SortField.FIELD_DOC });
-		assertMatches (empty, queryX, sort, "");
-
-		sort.setSort (new SortField[] { new SortField ("string", SortField.STRING, true), SortField.FIELD_DOC });
-		assertMatches (empty, queryX, sort, "");
-
-		sort.setSort (new SortField[] { new SortField ("float", SortField.FLOAT), new SortField ("string", SortField.STRING) });
-		assertMatches (empty, queryX, sort, "");
-	}
-
-	// test sorts where the type of field is determined dynamically
-	public void testAutoSort() throws Exception {
-		sort.setSort("int");
-		assertMatches (full, queryX, sort, "IGAEC");
-		assertMatches (full, queryY, sort, "DHFJB");
-
-		sort.setSort("float");
-		assertMatches (full, queryX, sort, "GCIEA");
-		assertMatches (full, queryY, sort, "DHJFB");
-
-		sort.setSort("string");
-		assertMatches (full, queryX, sort, "AIGEC");
-		assertMatches (full, queryY, sort, "DJHFB");
-	}
-
-	// test sorts in reverse
-	public void testReverseSort() throws Exception {
-		sort.setSort (new SortField[] { new SortField (null, SortField.SCORE, true), SortField.FIELD_DOC });
-		assertMatches (full, queryX, sort, "IEGCA");
-		assertMatches (full, queryY, sort, "JFHDB");
-
-		sort.setSort (new SortField (null, SortField.DOC, true));
-		assertMatches (full, queryX, sort, "IGECA");
-		assertMatches (full, queryY, sort, "JHFDB");
-
-		sort.setSort ("int", true);
-		assertMatches (full, queryX, sort, "CAEGI");
-		assertMatches (full, queryY, sort, "BJFHD");
-
-		sort.setSort ("float", true);
-		assertMatches (full, queryX, sort, "AECIG");
-		assertMatches (full, queryY, sort, "BFJHD");
-
-		sort.setSort ("string", true);
-		assertMatches (full, queryX, sort, "CEGIA");
-		assertMatches (full, queryY, sort, "BFHJD");
-	}
-
-	// test sorting when the sort field is empty (undefined) for some of the documents
-	public void testEmptyFieldSort() throws Exception {
-		sort.setSort ("string");
-		assertMatches (full, queryF, sort, "ZJI");
-
-		sort.setSort ("string", true);
-		assertMatches (full, queryF, sort, "IJZ");
-		
-		sort.setSort (new SortField ("i18n", Locale.ENGLISH));
-		assertMatches (full, queryF, sort, "ZJI");
-		
-		sort.setSort (new SortField ("i18n", Locale.ENGLISH, true));
-		assertMatches (full, queryF, sort, "IJZ");
-
-		sort.setSort ("int");
-		assertMatches (full, queryF, sort, "IZJ");
-
-		sort.setSort ("int", true);
-		assertMatches (full, queryF, sort, "JZI");
-
-		sort.setSort ("float");
-		assertMatches (full, queryF, sort, "ZJI");
-
-		// using a nonexisting field as first sort key shouldn't make a difference:
-		sort.setSort (new SortField[] { new SortField ("nosuchfield", SortField.STRING),
-				new SortField ("float") });
-		assertMatches (full, queryF, sort, "ZJI");
+    assertMatches (full, queryX, sort, "AIGEC");
+    assertMatches (full, queryY, sort, "DJHFB");
+  }
+  
+  /**
+   * Test String sorting: small queue to many matches, multi field sort, reverse sort
+   */
+  public void testStringSort() throws IOException, ParseException {
+    ScoreDoc[] result = null;
+    IndexSearcher searcher = getFullStrings();
+    sort.setSort(new SortField[] {
+        new SortField("string", SortField.STRING),
+        new SortField("string2", SortField.STRING, true),
+        SortField.FIELD_DOC });
+
+    result = searcher.search(new MatchAllDocsQuery(), null, 500, sort).scoreDocs;
+
+    StringBuffer buff = new StringBuffer();
+    int n = result.length;
+    String last = null;
+    String lastSub = null;
+    int lastDocId = 0;
+    boolean fail = false;
+    for (int x = 0; x < n; ++x) {
+      Document doc2 = searcher.doc(result[x].doc);
+      String[] v = doc2.getValues("tracer");
+      String[] v2 = doc2.getValues("tracer2");
+      for (int j = 0; j < v.length; ++j) {
+        if (last != null) {
+          int cmp = v[j].compareTo(last);
+          if (!(cmp >= 0)) { // ensure first field is in order
+            fail = true;
+            System.out.println("fail:" + v[j] + " < " + last);
+          }
+          if (cmp == 0) { // ensure second field is in reverse order
+            cmp = v2[j].compareTo(lastSub);
+            if (cmp > 0) {
+              fail = true;
+              System.out.println("rev field fail:" + v2[j] + " > " + lastSub);
+            } else if(cmp == 0) { // ensure docid is in order
+              if (result[x].doc < lastDocId) {
+                fail = true;
+                System.out.println("doc fail:" + result[x].doc + " > " + lastDocId);
+              }
+            }
+          }
+        }
+        last = v[j];
+        lastSub = v2[j];
+        lastDocId = result[x].doc;
+        buff.append(v[j] + "(" + v2[j] + ")(" + result[x].doc+") ");
+      }
+    }
+    if(fail) {
+      System.out.println("topn field1(field2)(docID):" + buff);
+    }
+    assertFalse("Found sort results out of order", fail);
+
+  }
+  
+  // test sorts where the type of field is specified and a custom field parser is used, that
+  // uses a simple char encoding. The sorted string contains a character beginning from 'A' that
+  // is mapped to a numeric value using some "funny" algorithm to be different for each data type.
+  public void testCustomFieldParserSort() throws Exception {
+    sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.IntParser(){
+      public final int parseInt(final String val) {
+        return (int) (val.charAt(0)-'A') * 123456;
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+
+    sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.FloatParser(){
+      public final float parseFloat(final String val) {
+        return (float) Math.sqrt( (double) val.charAt(0) );
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+
+    sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.LongParser(){
+      public final long parseLong(final String val) {
+        return (long) (val.charAt(0)-'A') * 1234567890L;
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+
+    sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.DoubleParser(){
+      public final double parseDouble(final String val) {
+        return Math.pow( (double) val.charAt(0), (double) (val.charAt(0)-'A') );
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+
+    sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.ByteParser(){
+      public final byte parseByte(final String val) {
+        return (byte) (val.charAt(0)-'A');
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+
+    sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.ShortParser(){
+      public final short parseShort(final String val) {
+        return (short) (val.charAt(0)-'A');
+      }
+    }), SortField.FIELD_DOC });
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+  }
+
+  // test sorts when there's nothing in the index
+  public void testEmptyIndex() throws Exception {
+    Searcher empty = getEmptyIndex();
+
+    sort = new Sort();
+    assertMatches (empty, queryX, sort, "");
+
+    sort.setSort(SortField.FIELD_DOC);
+    assertMatches (empty, queryX, sort, "");
+
+    sort.setSort (new SortField[] { new SortField ("int", SortField.INT), SortField.FIELD_DOC });
+    assertMatches (empty, queryX, sort, "");
+
+    sort.setSort (new SortField[] { new SortField ("string", SortField.STRING, true), SortField.FIELD_DOC });
+    assertMatches (empty, queryX, sort, "");
+
+    sort.setSort (new SortField[] { new SortField ("float", SortField.FLOAT), new SortField ("string", SortField.STRING) });
+    assertMatches (empty, queryX, sort, "");
+  }
+
+  static class MyFieldComparator extends FieldComparator {
+    int[] docValues;
+    int[] slotValues;
+    int bottomValue;
+
+    MyFieldComparator(int numHits) {
+      slotValues = new int[numHits];
+    }
+
+    public void copy(int slot, int doc, float score) {
+      slotValues[slot] = docValues[doc];
+    }
+
+    public int compare(int slot1, int slot2) {
+      return slotValues[slot1] - slotValues[slot2];
+    }
+
+    public int compareBottom(int doc, float score) {
+      return bottomValue - docValues[doc];
+    }
+
+    public void setBottom(int bottom) {
+      bottomValue = slotValues[bottom];
+    }
+
+    public void setNextReader(IndexReader reader, int docBase, int numSlotsFull) throws IOException {
+      docValues = FieldCache.DEFAULT.getInts(reader, "parser", new FieldCache.IntParser() {
+          public final int parseInt(final String val) {
+            return (int) (val.charAt(0)-'A') * 123456;
+          }
+        });
+    }
+
+    public int sortType() {
+      return 0;
+    }
+
+    public Comparable value(int slot) {
+      return new Integer(slotValues[slot]);
+    }
+  }
+
+  static class MyFieldComparatorSource extends FieldComparatorSource {
+    FieldComparator newComparator(String fieldname, IndexReader[] subReaders, int numHits, int sortPos, boolean reversed) {
+      return new MyFieldComparator(numHits);
+    }
+  }
+
+  // Test sorting w/ custom FieldComparator
+  public void testNewCustomFieldParserSort() throws Exception {
+    sort.setSort (new SortField[] { new SortField ("parser", new MyFieldComparatorSource())});
+    assertMatches (full, queryA, sort, "JIHGFEDCBA");
+  }
+
+  // test sorts where the type of field is determined dynamically
+  public void testAutoSort() throws Exception {
+    sort.setSort("int");
+    assertMatches (full, queryX, sort, "IGAEC");
+    assertMatches (full, queryY, sort, "DHFJB");
+
+    sort.setSort("float");
+    assertMatches (full, queryX, sort, "GCIEA");
+    assertMatches (full, queryY, sort, "DHJFB");
+
+    sort.setSort("string");
+    assertMatches (full, queryX, sort, "AIGEC");
+    assertMatches (full, queryY, sort, "DJHFB");
+  }
+
+  // test sorts in reverse
+  public void testReverseSort() throws Exception {
+    sort.setSort (new SortField[] { new SortField (null, SortField.SCORE, true), SortField.FIELD_DOC });
+    assertMatches (full, queryX, sort, "IEGCA");
+    assertMatches (full, queryY, sort, "JFHDB");
+
+    sort.setSort (new SortField (null, SortField.DOC, true));
+    assertMatches (full, queryX, sort, "IGECA");
+    assertMatches (full, queryY, sort, "JHFDB");
+
+    sort.setSort ("int", true);
+    assertMatches (full, queryX, sort, "CAEGI");
+    assertMatches (full, queryY, sort, "BJFHD");
+
+    sort.setSort ("float", true);
+    assertMatches (full, queryX, sort, "AECIG");
+    assertMatches (full, queryY, sort, "BFJHD");
+
+    sort.setSort ("string", true);
+    assertMatches (full, queryX, sort, "CEGIA");
+    assertMatches (full, queryY, sort, "BFHJD");
+  }
+
+  // test sorting when the sort field is empty (undefined) for some of the documents
+  public void testEmptyFieldSort() throws Exception {
+    sort.setSort ("string");
+    assertMatches (full, queryF, sort, "ZJI");
+
+    sort.setSort ("string", true);
+    assertMatches (full, queryF, sort, "IJZ");
+    
+    sort.setSort (new SortField ("i18n", Locale.ENGLISH));
+    assertMatches (full, queryF, sort, "ZJI");
+    
+    sort.setSort (new SortField ("i18n", Locale.ENGLISH, true));
+    assertMatches (full, queryF, sort, "IJZ");
+
+    sort.setSort ("int");
+    assertMatches (full, queryF, sort, "IZJ");
+
+    sort.setSort ("int", true);
+    assertMatches (full, queryF, sort, "JZI");
 
-		sort.setSort ("float", true);
-		assertMatches (full, queryF, sort, "IJZ");
+    sort.setSort ("float");
+    assertMatches (full, queryF, sort, "ZJI");
 
-		// When a field is null for both documents, the next SortField should be used.
+    // using a nonexisting field as first sort key shouldn't make a difference:
+    sort.setSort (new SortField[] { new SortField ("nosuchfield", SortField.STRING),
+        new SortField ("float") });
+    assertMatches (full, queryF, sort, "ZJI");
+
+    sort.setSort ("float", true);
+    assertMatches (full, queryF, sort, "IJZ");
+
+    // When a field is null for both documents, the next SortField should be used.
                 // Works for
-		sort.setSort (new SortField[] { new SortField ("int"),
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float") });
-		assertMatches (full, queryG, sort, "ZWXY");
+        new SortField ("float") });
+    assertMatches (full, queryG, sort, "ZWXY");
 
-		// Reverse the last criterium to make sure the test didn't pass by chance
-		sort.setSort (new SortField[] { new SortField ("int"),
+    // Reverse the last criterium to make sure the test didn't pass by chance
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float", true) });
-		assertMatches (full, queryG, sort, "ZYXW");
+        new SortField ("float", true) });
+    assertMatches (full, queryG, sort, "ZYXW");
 
-		// Do the same for a MultiSearcher
-		Searcher multiSearcher=new MultiSearcher (new Searchable[] { full });
+    // Do the same for a MultiSearcher
+    Searcher multiSearcher=new MultiSearcher (new Searchable[] { full });
 
-		sort.setSort (new SortField[] { new SortField ("int"),
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float") });
-		assertMatches (multiSearcher, queryG, sort, "ZWXY");
+        new SortField ("float") });
+    assertMatches (multiSearcher, queryG, sort, "ZWXY");
 
-		sort.setSort (new SortField[] { new SortField ("int"),
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float", true) });
-		assertMatches (multiSearcher, queryG, sort, "ZYXW");
-		// Don't close the multiSearcher. it would close the full searcher too!
+        new SortField ("float", true) });
+    assertMatches (multiSearcher, queryG, sort, "ZYXW");
+    // Don't close the multiSearcher. it would close the full searcher too!
 
-		// Do the same for a ParallelMultiSearcher
+    // Do the same for a ParallelMultiSearcher
                 Searcher parallelSearcher=new ParallelMultiSearcher (new Searchable[] { full });
 
-		sort.setSort (new SortField[] { new SortField ("int"),
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float") });
-		assertMatches (parallelSearcher, queryG, sort, "ZWXY");
+        new SortField ("float") });
+    assertMatches (parallelSearcher, queryG, sort, "ZWXY");
 
-		sort.setSort (new SortField[] { new SortField ("int"),
+    sort.setSort (new SortField[] { new SortField ("int"),
                                 new SortField ("string", SortField.STRING),
-				new SortField ("float", true) });
-		assertMatches (parallelSearcher, queryG, sort, "ZYXW");
-		// Don't close the parallelSearcher. it would close the full searcher too!
-	}
-
-	// test sorts using a series of fields
-	public void testSortCombos() throws Exception {
-		sort.setSort (new String[] {"int","float"});
-		assertMatches (full, queryX, sort, "IGEAC");
-
-		sort.setSort (new SortField[] { new SortField ("int", true), new SortField (null, SortField.DOC, true) });
-		assertMatches (full, queryX, sort, "CEAGI");
-
-		sort.setSort (new String[] {"float","string"});
-		assertMatches (full, queryX, sort, "GICEA");
-	}
-
-	// test using a Locale for sorting strings
-	public void testLocaleSort() throws Exception {
-		sort.setSort (new SortField[] { new SortField ("string", Locale.US) });
-		assertMatches (full, queryX, sort, "AIGEC");
-		assertMatches (full, queryY, sort, "DJHFB");
-
-		sort.setSort (new SortField[] { new SortField ("string", Locale.US, true) });
-		assertMatches (full, queryX, sort, "CEGIA");
-		assertMatches (full, queryY, sort, "BFHJD");
-	}
-
-	// test using various international locales with accented characters
-	// (which sort differently depending on locale)
-	public void testInternationalSort() throws Exception {
-		sort.setSort (new SortField ("i18n", Locale.US));
-		assertMatches (full, queryY, sort, "BFJDH");
-
-		sort.setSort (new SortField ("i18n", new Locale("sv", "se")));
-		assertMatches (full, queryY, sort, "BJDFH");
-
-		sort.setSort (new SortField ("i18n", new Locale("da", "dk")));
-		assertMatches (full, queryY, sort, "BJDHF");
-
-		sort.setSort (new SortField ("i18n", Locale.US));
-		assertMatches (full, queryX, sort, "ECAGI");
-
-		sort.setSort (new SortField ("i18n", Locale.FRANCE));
-		assertMatches (full, queryX, sort, "EACGI");
-	}
+        new SortField ("float", true) });
+    assertMatches (parallelSearcher, queryG, sort, "ZYXW");
+    // Don't close the parallelSearcher. it would close the full searcher too!
+  }
+
+  // test sorts using a series of fields
+  public void testSortCombos() throws Exception {
+    sort.setSort (new String[] {"int","float"});
+    assertMatches (full, queryX, sort, "IGEAC");
+
+    sort.setSort (new SortField[] { new SortField ("int", true), new SortField (null, SortField.DOC, true) });
+    assertMatches (full, queryX, sort, "CEAGI");
+
+    sort.setSort (new String[] {"float","string"});
+    assertMatches (full, queryX, sort, "GICEA");
+  }
+
+  // test using a Locale for sorting strings
+  public void testLocaleSort() throws Exception {
+    sort.setSort (new SortField[] { new SortField ("string", Locale.US) });
+    assertMatches (full, queryX, sort, "AIGEC");
+    assertMatches (full, queryY, sort, "DJHFB");
+
+    sort.setSort (new SortField[] { new SortField ("string", Locale.US, true) });
+    assertMatches (full, queryX, sort, "CEGIA");
+    assertMatches (full, queryY, sort, "BFHJD");
+  }
+
+  // test using various international locales with accented characters
+  // (which sort differently depending on locale)
+  public void testInternationalSort() throws Exception {
+    sort.setSort (new SortField ("i18n", Locale.US));
+    assertMatches (full, queryY, sort, "BFJDH");
+
+    sort.setSort (new SortField ("i18n", new Locale("sv", "se")));
+    assertMatches (full, queryY, sort, "BJDFH");
+
+    sort.setSort (new SortField ("i18n", new Locale("da", "dk")));
+    assertMatches (full, queryY, sort, "BJDHF");
+
+    sort.setSort (new SortField ("i18n", Locale.US));
+    assertMatches (full, queryX, sort, "ECAGI");
+
+    sort.setSort (new SortField ("i18n", Locale.FRANCE));
+    assertMatches (full, queryX, sort, "EACGI");
+  }
     
     // Test the MultiSearcher's ability to preserve locale-sensitive ordering
     // by wrapping it around a single searcher
-	public void testInternationalMultiSearcherSort() throws Exception {
-		Searcher multiSearcher = new MultiSearcher (new Searchable[] { full });
-		
-		sort.setSort (new SortField ("i18n", new Locale("sv", "se")));
-		assertMatches (multiSearcher, queryY, sort, "BJDFH");
-		
-		sort.setSort (new SortField ("i18n", Locale.US));
-		assertMatches (multiSearcher, queryY, sort, "BFJDH");
-		
-		sort.setSort (new SortField ("i18n", new Locale("da", "dk")));
-		assertMatches (multiSearcher, queryY, sort, "BJDHF");
-	} 
+  public void testInternationalMultiSearcherSort() throws Exception {
+    Searcher multiSearcher = new MultiSearcher (new Searchable[] { full });
+    
+    sort.setSort (new SortField ("i18n", new Locale("sv", "se")));
+    assertMatches (multiSearcher, queryY, sort, "BJDFH");
     
-	// test a custom sort function
-	public void testCustomSorts() throws Exception {
-		sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource()));
-		assertMatches (full, queryX, sort, "CAIEG");
-		sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource(), true));
-		assertMatches (full, queryY, sort, "HJDBF");
-		SortComparator custom = SampleComparable.getComparator();
-		sort.setSort (new SortField ("custom", custom));
-		assertMatches (full, queryX, sort, "CAIEG");
-		sort.setSort (new SortField ("custom", custom, true));
-		assertMatches (full, queryY, sort, "HJDBF");
-	}
-
-	// test a variety of sorts using more than one searcher
-	public void testMultiSort() throws Exception {
-		MultiSearcher searcher = new MultiSearcher (new Searchable[] { searchX, searchY });
-		runMultiSorts (searcher);
-	}
-
-	// test a variety of sorts using a parallel multisearcher
-	public void testParallelMultiSort() throws Exception {
-		Searcher searcher = new ParallelMultiSearcher (new Searchable[] { searchX, searchY });
-		runMultiSorts (searcher);
-	}
-
-	// test a variety of sorts using a remote searcher
-	public void testRemoteSort() throws Exception {
-		Searchable searcher = getRemote();
-		MultiSearcher multi = new MultiSearcher (new Searchable[] { searcher });
-		runMultiSorts (multi);
-	}
-
-	// test custom search when remote
-	public void testRemoteCustomSort() throws Exception {
-		Searchable searcher = getRemote();
-		MultiSearcher multi = new MultiSearcher (new Searchable[] { searcher });
-		sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource()));
-		assertMatches (multi, queryX, sort, "CAIEG");
-		sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource(), true));
-		assertMatches (multi, queryY, sort, "HJDBF");
-		SortComparator custom = SampleComparable.getComparator();
-		sort.setSort (new SortField ("custom", custom));
-		assertMatches (multi, queryX, sort, "CAIEG");
-		sort.setSort (new SortField ("custom", custom, true));
-		assertMatches (multi, queryY, sort, "HJDBF");
-	}
-
-	// test that the relevancy scores are the same even if
-	// hits are sorted
-	public void testNormalizedScores() throws Exception {
+    sort.setSort (new SortField ("i18n", Locale.US));
+    assertMatches (multiSearcher, queryY, sort, "BFJDH");
+    
+    sort.setSort (new SortField ("i18n", new Locale("da", "dk")));
+    assertMatches (multiSearcher, queryY, sort, "BJDHF");
+  } 
+    
+  // test a custom sort function
+  public void testCustomSorts() throws Exception {
+    sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource()));
+    assertMatches (full, queryX, sort, "CAIEG");
+    sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource(), true));
+    assertMatches (full, queryY, sort, "HJDBF");
+    SortComparator custom = SampleComparable.getComparator();
+    sort.setSort (new SortField ("custom", custom));
+    assertMatches (full, queryX, sort, "CAIEG");
+    sort.setSort (new SortField ("custom", custom, true));
+    assertMatches (full, queryY, sort, "HJDBF");
+  }
+
+  // test a variety of sorts using more than one searcher
+  public void testMultiSort() throws Exception {
+    MultiSearcher searcher = new MultiSearcher (new Searchable[] { searchX, searchY });
+    runMultiSorts (searcher);
+  }
+
+  // test a variety of sorts using a parallel multisearcher
+  public void testParallelMultiSort() throws Exception {
+    Searcher searcher = new ParallelMultiSearcher (new Searchable[] { searchX, searchY });
+    runMultiSorts (searcher);
+  }
 
-		// capture relevancy scores
+  // test a variety of sorts using a remote searcher
+  public void testRemoteSort() throws Exception {
+    Searchable searcher = getRemote();
+    MultiSearcher multi = new MultiSearcher (new Searchable[] { searcher });
+    runMultiSorts (multi);
+  }
+
+  // test custom search when remote
+  public void testRemoteCustomSort() throws Exception {
+    Searchable searcher = getRemote();
+    MultiSearcher multi = new MultiSearcher (new Searchable[] { searcher });
+    sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource()));
+    assertMatches (multi, queryX, sort, "CAIEG");
+    sort.setSort (new SortField ("custom", SampleComparable.getComparatorSource(), true));
+    assertMatches (multi, queryY, sort, "HJDBF");
+    SortComparator custom = SampleComparable.getComparator();
+    sort.setSort (new SortField ("custom", custom));
+    assertMatches (multi, queryX, sort, "CAIEG");
+    sort.setSort (new SortField ("custom", custom, true));
+    assertMatches (multi, queryY, sort, "HJDBF");
+  }
+
+  // test that the relevancy scores are the same even if
+  // hits are sorted
+  public void testNormalizedScores() throws Exception {
+
+    // capture relevancy scores
     HashMap scoresX = getScores (full.search (queryX, null, 1000).scoreDocs, full);
     HashMap scoresY = getScores (full.search (queryY, null, 1000).scoreDocs, full);
     HashMap scoresA = getScores (full.search (queryA, null, 1000).scoreDocs, full);
 
-		// we'll test searching locally, remote and multi
-		MultiSearcher remote = new MultiSearcher (new Searchable[] { getRemote() });
-		MultiSearcher multi  = new MultiSearcher (new Searchable[] { searchX, searchY });
+    // we'll test searching locally, remote and multi
+    MultiSearcher remote = new MultiSearcher (new Searchable[] { getRemote() });
+    MultiSearcher multi  = new MultiSearcher (new Searchable[] { searchX, searchY });
 
-		// change sorting and make sure relevancy stays the same
+    // change sorting and make sure relevancy stays the same
 
-		sort = new Sort();
+    sort = new Sort();
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -527,7 +698,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort(SortField.FIELD_DOC);
+    sort.setSort(SortField.FIELD_DOC);
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -538,7 +709,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort ("int");
+    sort.setSort ("int");
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -549,7 +720,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort ("float");
+    sort.setSort ("float");
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -560,7 +731,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort ("string");
+    sort.setSort ("string");
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -571,7 +742,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort (new String[] {"int","float"});
+    sort.setSort (new String[] {"int","float"});
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -582,7 +753,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort (new SortField[] { new SortField ("int", true), new SortField (null, SortField.DOC, true) });
+    sort.setSort (new SortField[] { new SortField ("int", true), new SortField (null, SortField.DOC, true) });
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -593,7 +764,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-		sort.setSort (new String[] {"float","string"});
+    sort.setSort (new String[] {"float","string"});
     assertSameValues (scoresX, getScores (full.search (queryX, null, 1000, sort).scoreDocs, full));
     assertSameValues (scoresX, getScores (remote.search (queryX, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresX, getScores (multi.search (queryX, null, 1000, sort).scoreDocs, multi));
@@ -604,7 +775,7 @@
     assertSameValues (scoresA, getScores (remote.search (queryA, null, 1000, sort).scoreDocs, remote));
     assertSameValues (scoresA, getScores (multi.search (queryA, null, 1000, sort).scoreDocs, multi));
 
-	}
+  }
 
   public void testTopDocsScores() throws Exception {
 
@@ -621,6 +792,7 @@
     Filter filt = new Filter() {
       public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
         BitSet bs = new BitSet(reader.maxDoc());
+        bs.set(0, reader.maxDoc());
         bs.set(docs1.scoreDocs[0].doc);
         return new DocIdBitSet(bs);
       }
@@ -631,121 +803,123 @@
     assertEquals(docs1.scoreDocs[0].score, docs2.scoreDocs[0].score, 1e-6);
   }
 
-
   // runs a variety of sorts useful for multisearchers
-	private void runMultiSorts (Searcher multi) throws Exception {
-		sort.setSort (SortField.FIELD_DOC);
-		assertMatchesPattern (multi, queryA, sort, "[AB]{2}[CD]{2}[EF]{2}[GH]{2}[IJ]{2}");
+  private void runMultiSorts (Searcher multi) throws Exception {
+    sort.setSort (SortField.FIELD_DOC);
+    assertMatchesPattern (multi, queryA, sort, "[AB]{2}[CD]{2}[EF]{2}[GH]{2}[IJ]{2}");
 
-		sort.setSort (new SortField ("int", SortField.INT));
-		assertMatchesPattern (multi, queryA, sort, "IDHFGJ[ABE]{3}C");
+    sort.setSort (new SortField ("int", SortField.INT));
+    assertMatchesPattern (multi, queryA, sort, "IDHFGJ[ABE]{3}C");
 
-		sort.setSort (new SortField[] {new SortField ("int", SortField.INT), SortField.FIELD_DOC});
-		assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
+    sort.setSort (new SortField[] {new SortField ("int", SortField.INT), SortField.FIELD_DOC});
+    assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
 
-		sort.setSort ("int");
-		assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
+    sort.setSort ("int");
+    assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
 
-		sort.setSort (new SortField[] {new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC});
-		assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
+    sort.setSort (new SortField[] {new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC});
+    assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
 
-		sort.setSort ("float");
-		assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
+    sort.setSort ("float");
+    assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
 
-		sort.setSort ("string");
-		assertMatches (multi, queryA, sort, "DJAIHGFEBC");
+    sort.setSort ("string");
+    assertMatches (multi, queryA, sort, "DJAIHGFEBC");
 
-		sort.setSort ("int", true);
-		assertMatchesPattern (multi, queryA, sort, "C[AB]{2}EJGFHDI");
+    sort.setSort ("int", true);
+    assertMatchesPattern (multi, queryA, sort, "C[AB]{2}EJGFHDI");
 
-		sort.setSort ("float", true);
-		assertMatchesPattern (multi, queryA, sort, "BAFE[IC]{2}JHDG");
+    sort.setSort ("float", true);
+    assertMatchesPattern (multi, queryA, sort, "BAFE[IC]{2}JHDG");
 
-		sort.setSort ("string", true);
-		assertMatches (multi, queryA, sort, "CBEFGHIAJD");
+    sort.setSort ("string", true);
+    assertMatches (multi, queryA, sort, "CBEFGHIAJD");
 
-		sort.setSort (new SortField[] { new SortField ("string", Locale.US) });
-		assertMatches (multi, queryA, sort, "DJAIHGFEBC");
+    sort.setSort (new SortField[] { new SortField ("string", Locale.US) });
+    assertMatches (multi, queryA, sort, "DJAIHGFEBC");
 
-		sort.setSort (new SortField[] { new SortField ("string", Locale.US, true) });
-		assertMatches (multi, queryA, sort, "CBEFGHIAJD");
+    sort.setSort (new SortField[] { new SortField ("string", Locale.US, true) });
+    assertMatches (multi, queryA, sort, "CBEFGHIAJD");
 
-		sort.setSort (new String[] {"int","float"});
-		assertMatches (multi, queryA, sort, "IDHFGJEABC");
+    sort.setSort (new String[] {"int","float"});
+    assertMatches (multi, queryA, sort, "IDHFGJEABC");
 
-		sort.setSort (new String[] {"float","string"});
-		assertMatches (multi, queryA, sort, "GDHJICEFAB");
+    sort.setSort (new String[] {"float","string"});
+    assertMatches (multi, queryA, sort, "GDHJICEFAB");
 
-		sort.setSort ("int");
-		assertMatches (multi, queryF, sort, "IZJ");
+    sort.setSort ("int");
+    assertMatches (multi, queryF, sort, "IZJ");
 
-		sort.setSort ("int", true);
-		assertMatches (multi, queryF, sort, "JZI");
+    sort.setSort ("int", true);
+    assertMatches (multi, queryF, sort, "JZI");
 
-		sort.setSort ("float");
-		assertMatches (multi, queryF, sort, "ZJI");
+    sort.setSort ("float");
+    assertMatches (multi, queryF, sort, "ZJI");
 
-		sort.setSort ("string");
-		assertMatches (multi, queryF, sort, "ZJI");
+    sort.setSort ("string");
+    assertMatches (multi, queryF, sort, "ZJI");
 
-		sort.setSort ("string", true);
-		assertMatches (multi, queryF, sort, "IJZ");
-	}
+    sort.setSort ("string", true);
+    assertMatches (multi, queryF, sort, "IJZ");
+  }
 
-	// make sure the documents returned by the search match the expected list
-	private void assertMatches (Searcher searcher, Query query, Sort sort, String expectedResult)
-	throws IOException {
-    ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
-		StringBuffer buff = new StringBuffer(10);
+  // make sure the documents returned by the search match the expected list
+  private void assertMatches (Searcher searcher, Query query, Sort sort, String expectedResult)
+  throws IOException {
+    //ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
+    TopDocs hits = searcher.search (query, null, expectedResult.length(), sort);
+    ScoreDoc[] result = hits.scoreDocs;
+    assertEquals(hits.totalHits, expectedResult.length());
+    StringBuffer buff = new StringBuffer(10);
     int n = result.length;
-		for (int i=0; i<n; ++i) {
+    for (int i=0; i<n; ++i) {
       Document doc = searcher.doc(result[i].doc);
-			String[] v = doc.getValues("tracer");
-			for (int j=0; j<v.length; ++j) {
-				buff.append (v[j]);
-			}
-		}
-		assertEquals (expectedResult, buff.toString());
-	}
-
-	// make sure the documents returned by the search match the expected list pattern
-	private void assertMatchesPattern (Searcher searcher, Query query, Sort sort, String pattern)
-	throws IOException {
+      String[] v = doc.getValues("tracer");
+      for (int j=0; j<v.length; ++j) {
+        buff.append (v[j]);
+      }
+    }
+    assertEquals (expectedResult, buff.toString());
+  }
+
+  // make sure the documents returned by the search match the expected list pattern
+  private void assertMatchesPattern (Searcher searcher, Query query, Sort sort, String pattern)
+  throws IOException {
     ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
-		StringBuffer buff = new StringBuffer(10);
+    StringBuffer buff = new StringBuffer(10);
     int n = result.length;
-		for (int i=0; i<n; ++i) {
+    for (int i=0; i<n; ++i) {
       Document doc = searcher.doc(result[i].doc);
-			String[] v = doc.getValues("tracer");
-			for (int j=0; j<v.length; ++j) {
-				buff.append (v[j]);
-			}
-		}
-		// System.out.println ("matching \""+buff+"\" against pattern \""+pattern+"\"");
-		assertTrue (Pattern.compile(pattern).matcher(buff.toString()).matches());
-	}
+      String[] v = doc.getValues("tracer");
+      for (int j=0; j<v.length; ++j) {
+        buff.append (v[j]);
+      }
+    }
+    // System.out.println ("matching \""+buff+"\" against pattern \""+pattern+"\"");
+    assertTrue (Pattern.compile(pattern).matcher(buff.toString()).matches());
+  }
 
   private HashMap getScores (ScoreDoc[] hits, Searcher searcher)
-	throws IOException {
-		HashMap scoreMap = new HashMap();
+  throws IOException {
+    HashMap scoreMap = new HashMap();
     int n = hits.length;
-		for (int i=0; i<n; ++i) {
+    for (int i=0; i<n; ++i) {
       Document doc = searcher.doc(hits[i].doc);
-			String[] v = doc.getValues("tracer");
-			assertEquals (v.length, 1);
+      String[] v = doc.getValues("tracer");
+      assertEquals (v.length, 1);
       scoreMap.put (v[0], new Float(hits[i].score));
-		}
-		return scoreMap;
-	}
-
-	// make sure all the values in the maps match
-	private void assertSameValues (HashMap m1, HashMap m2) {
-		int n = m1.size();
-		int m = m2.size();
-		assertEquals (n, m);
-		Iterator iter = m1.keySet().iterator();
-		while (iter.hasNext()) {
-			Object key = iter.next();
+    }
+    return scoreMap;
+  }
+
+  // make sure all the values in the maps match
+  private void assertSameValues (HashMap m1, HashMap m2) {
+    int n = m1.size();
+    int m = m2.size();
+    assertEquals (n, m);
+    Iterator iter = m1.keySet().iterator();
+    while (iter.hasNext()) {
+      Object key = iter.next();
       Object o1 = m1.get(key);
       Object o2 = m2.get(key);
       if (o1 instanceof Float) {
@@ -753,31 +927,31 @@
       } else {
         assertEquals (m1.get(key), m2.get(key));
       }
-		}
-	}
+    }
+  }
+
+  private Searchable getRemote () throws Exception {
+    try {
+      return lookupRemote ();
+    } catch (Throwable e) {
+      startServer ();
+      return lookupRemote ();
+    }
+  }
 
-	private Searchable getRemote () throws Exception {
-		try {
-			return lookupRemote ();
-		} catch (Throwable e) {
-			startServer ();
-			return lookupRemote ();
-		}
-	}
-
-	private Searchable lookupRemote () throws Exception {
-		return (Searchable) Naming.lookup ("//localhost/SortedSearchable");
-	}
-
-	private void startServer () throws Exception {
-		// construct an index
-		Searcher local = getFullIndex();
-		// local.search (queryA, new Sort());
-
-		// publish it
-		Registry reg = LocateRegistry.createRegistry (1099);
-		RemoteSearchable impl = new RemoteSearchable (local);
-		Naming.rebind ("//localhost/SortedSearchable", impl);
-	}
+  private Searchable lookupRemote () throws Exception {
+    return (Searchable) Naming.lookup ("//localhost/SortedSearchable");
+  }
+
+  private void startServer () throws Exception {
+    // construct an index
+    Searcher local = getFullIndex();
+    // local.search (queryA, new Sort());
+
+    // publish it
+    LocateRegistry.createRegistry (1099);
+    RemoteSearchable impl = new RemoteSearchable (local);
+    Naming.rebind ("//localhost/SortedSearchable", impl);
+  }
 
 }

Added: lucene/java/trunk/src/test/org/apache/lucene/search/TestStressSort.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/src/test/org/apache/lucene/search/TestStressSort.java?rev=738219&view=auto
==============================================================================
--- lucene/java/trunk/src/test/org/apache/lucene/search/TestStressSort.java (added)
+++ lucene/java/trunk/src/test/org/apache/lucene/search/TestStressSort.java Tue Jan 27 20:15:21 2009
@@ -0,0 +1,354 @@
+package org.apache.lucene.search;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.store.MockRAMDirectory;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+
+import java.util.Random;
+import java.util.Arrays;
+
+public class TestStressSort extends LuceneTestCase {
+
+  private final static int NUM_DOCS = 5000;
+  // NOTE: put seed in here to make failures
+  // deterministic, but do not commit with a seed (to
+  // better test):
+  private final Random r = new Random();
+  private Directory dir, dir2, dir3;
+  private IndexSearcher searcherMultiSegment;
+  private IndexSearcher searcherFewSegment;
+  private IndexSearcher searcherSingleSegment;
+
+  private static final boolean VERBOSE = false;
+
+  // min..max
+  private int nextInt(int min, int max) {
+    return min + r.nextInt(max-min+1);
+  }
+
+  // 0..(lim-1)
+  private int nextInt(int lim) {
+    return r.nextInt(lim);
+  }
+
+  final char[] buffer = new char[20];
+  private String randomString(int size) {
+    assert size < 20;
+    for(int i=0;i<size;i++) {
+      buffer[i] = (char) nextInt(48, 122);
+    }
+    return new String(buffer, 0, size);
+  }
+
+  private void create() throws Throwable {
+
+    // NOTE: put seed in here to make failures
+    // deterministic, but do not commit with a seed (to
+    // better test):
+    final Random r = new Random();
+    dir = new MockRAMDirectory();
+    IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
+    writer.setMaxBufferedDocs(17);
+
+    final Document doc = new Document();
+    final Document doc2 = new Document();
+
+    final Field id = new Field("id", "", Field.Store.YES, Field.Index.NO);
+    doc.add(id);
+    doc2.add(id);
+
+    final Field contents = new Field("contents", "", Field.Store.NO, Field.Index.ANALYZED);
+    doc.add(contents);
+    doc2.add(contents);
+
+    final Field byteField = new Field("byte", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(byteField);
+    doc2.add(byteField);
+
+    final Field shortField = new Field("short", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(shortField);
+    doc2.add(shortField);
+
+    final Field intField = new Field("int", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(intField);
+    doc2.add(intField);
+
+    final Field longField = new Field("long", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(longField);
+    doc2.add(longField);
+
+    final Field floatField = new Field("float", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(floatField);
+    doc2.add(floatField);
+
+    final Field doubleField = new Field("double", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(doubleField);
+    doc2.add(doubleField);
+
+    final Field stringField = new Field("string", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
+    doc.add(stringField);
+    // doc2 doesn't have stringField, so we get nulls
+
+    for(int i=0;i<NUM_DOCS;i++) {
+      id.setValue(""+i);
+      if (i % 1000 == 0) {
+        contents.setValue("a b c z");
+      } else if (i % 100 == 0) {
+        contents.setValue("a b c y");
+      } else if (i % 10 == 0) {
+        contents.setValue("a b c x");
+      } else {
+        contents.setValue("a b c");
+      }
+      byteField.setValue(""+nextInt(Byte.MIN_VALUE, Byte.MAX_VALUE));
+      if (nextInt(10) == 3) {
+        shortField.setValue(""+Short.MIN_VALUE);
+      } else if (nextInt(10) == 7) {
+        shortField.setValue(""+Short.MAX_VALUE);
+      } else {
+        shortField.setValue(""+nextInt(Short.MIN_VALUE, Short.MAX_VALUE));
+      }
+
+      if (nextInt(10) == 3) {
+        intField.setValue(""+Integer.MIN_VALUE);
+      } else if (nextInt(10) == 7) {
+        intField.setValue(""+Integer.MAX_VALUE);
+      } else {
+        intField.setValue(""+r.nextInt());
+      }
+
+      if (nextInt(10) == 3) {
+        longField.setValue(""+Long.MIN_VALUE);
+      } else if (nextInt(10) == 7) {
+        longField.setValue(""+Long.MAX_VALUE);
+      } else {
+        longField.setValue(""+r.nextLong());
+      }
+      floatField.setValue(""+r.nextFloat());
+      doubleField.setValue(""+r.nextDouble());
+      if (i % 197 == 0) {
+        writer.addDocument(doc2);
+      } else {
+        stringField.setValue(randomString(nextInt(20)));
+        writer.addDocument(doc);
+      }
+    }
+    writer.close();
+    searcherMultiSegment = new IndexSearcher(dir);
+
+    dir2 = new MockRAMDirectory(dir);
+    writer = new IndexWriter(dir2, new StandardAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
+    writer.optimize();
+    writer.close();
+    searcherSingleSegment = new IndexSearcher(dir2);
+
+    dir3 = new MockRAMDirectory(dir);
+    writer = new IndexWriter(dir3, new StandardAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
+    writer.optimize(3);
+    writer.close();
+    searcherFewSegment = new IndexSearcher(dir3);
+  }
+
+  private void close() throws Throwable {
+    searcherMultiSegment.close();
+    searcherFewSegment.close();
+    searcherSingleSegment.close();
+    dir.close();
+    dir2.close();
+  }
+
+  public void testSort() throws Throwable {
+
+    // reverse & not
+    // all types
+    // restrictive & non restrictive searches (on contents)
+
+    create();
+
+    Sort[] sorts = new Sort[50];
+    int sortCount = 0;
+
+    for(int r=0;r<2;r++) {
+      Sort sort;
+      boolean reverse = 1 == r;
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("byte", SortField.BYTE, reverse)});
+      
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("short", SortField.SHORT, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("int", SortField.INT, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("long", SortField.LONG, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("float", SortField.FLOAT, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("double", SortField.DOUBLE, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("string", SortField.STRING_VAL, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField("string", SortField.STRING, reverse)});
+
+      //sorts[sortCount++] = sort = new Sort();
+      //sort.setSort(new SortField[] {new SortField("string", SortField.STRING_ORD, reverse)});
+
+      //sorts[sortCount++] = sort = new Sort();
+      //sort.setSort(new SortField[] {new SortField("string", SortField.STRING_ORD_VAL, reverse)});
+
+      //sorts[sortCount++] = sort = new Sort();
+      //sort.setSort(new SortField[] {new SortField("string", SortField.STRING_ORD_VAL_DEM, reverse)});
+
+      //sorts[sortCount++] = sort = new Sort();
+      //sort.setSort(new SortField[] {new SortField("string", SortField.STRING_ORD_VAL_DEM2, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField(null, SortField.SCORE, reverse)});
+
+      sorts[sortCount++] = sort = new Sort();
+      sort.setSort(new SortField[] {new SortField(null, SortField.DOC, reverse)});
+    }
+
+    Query[] queries = new Query[4];
+    queries[0] = new MatchAllDocsQuery();
+    queries[1] = new TermQuery(new Term("contents", "x"));  // matches every 10th doc
+    queries[2] = new TermQuery(new Term("contents", "y"));  // matches every 100th doc
+    queries[3] = new TermQuery(new Term("contents", "z"));  // matches every 1000th doc
+
+    for(int sx=0;sx<3;sx++) {
+      final IndexSearcher searcher;
+      if (sx == 0) {
+        searcher = searcherSingleSegment;
+      } else if (sx == 1) {
+        searcher = searcherFewSegment;
+      } else {
+        searcher = searcherMultiSegment;
+      }
+
+      for(int qx=0;qx<queries.length;qx++) {
+        final Query query = queries[qx];
+
+        for(int q=0;q<3;q++) {
+
+          final int queueSize;
+          if (q == 0) {
+            queueSize = 10;
+          } else if (q == 1) {
+            queueSize = 100;
+          } else {
+            queueSize = 1000;
+          }
+        
+          for(int s=0;s<sortCount;s++) {
+            Sort sort1 = sorts[s];
+
+            for(int s2=-1;s2<sortCount;s2++) {
+              Sort sort;
+              if (s2 == -1) {
+                // Single field sort
+                sort = sort1;
+              } else {
+                sort = new Sort(new SortField[] {sort1.getSort()[0], sorts[s2].getSort()[0]});
+              }
+
+              // Old
+              Sort oldSort = getOldSort(sort);
+
+              if (VERBOSE) {
+                System.out.println("query=" + query);
+                if (sx == 0) {
+                  System.out.println("  single-segment index");
+                } else if (sx == 1) {
+                  System.out.println("  few-segment index");
+                } else {
+                  System.out.println("  many-segment index");
+                }
+                System.out.println("  numHit=" + queueSize);
+                System.out.println("  old=" + oldSort);
+                System.out.println("  new=" + sort);
+              }
+
+              TopDocs newHits = searcher.search(query, null, queueSize, sort);
+              TopDocs oldHits = searcher.search(query, null, queueSize, oldSort);
+
+              compare(oldHits, newHits);
+            }
+          }
+        }
+      }
+    }
+
+    close();
+  }
+
+  private Sort getOldSort(Sort sort) {
+    SortField[] fields = sort.getSort();
+    SortField[] oldFields = new SortField[fields.length];
+    for(int i=0;i<fields.length;i++) {
+      int sortType;
+      if (fields[i].getField() != null && fields[i].getField().equals("string")) {
+        sortType = SortField.STRING;
+      } else {
+        sortType = fields[i].getType();
+      }
+      oldFields[i] = new SortField(fields[i].getField(),
+                                   sortType,
+                                   fields[i].getReverse());
+      oldFields[i].setUseLegacySearch(true);
+    }
+    return new Sort(oldFields);
+  }
+
+  private void compare(TopDocs oldHits, TopDocs newHits) {
+    assertEquals(oldHits.totalHits, newHits.totalHits);
+    assertEquals(oldHits.scoreDocs.length, newHits.scoreDocs.length);
+    final ScoreDoc[] oldDocs = oldHits.scoreDocs;
+    final ScoreDoc[] newDocs = newHits.scoreDocs;
+
+    for(int i=0;i<oldDocs.length;i++) {
+      if (oldDocs[i] instanceof FieldDoc) {
+        assert newDocs[i] instanceof FieldDoc;
+        FieldDoc oldHit = (FieldDoc) oldDocs[i];
+        FieldDoc newHit = (FieldDoc) newDocs[i];
+        assertEquals("hit " + i + " of " + oldDocs.length + " differs: oldDoc=" + oldHit.doc + " vs newDoc=" + newHit.doc + " oldFields=" + Arrays.toString(oldHit.fields) + " newFields=" + Arrays.toString(newHit.fields),
+                     oldHit.doc, newHit.doc);
+        assertEquals(oldHit.score, newHit.score, 0.00001);
+        assertTrue(Arrays.equals(oldHit.fields, newHit.fields));
+      } else {
+        ScoreDoc oldHit = oldDocs[i];
+        ScoreDoc newHit = newDocs[i];
+        assertEquals(oldHit.doc, newHit.doc);
+        assertEquals(oldHit.score, newHit.score, 0.00001);
+      }
+    }
+    
+  }
+}

Propchange: lucene/java/trunk/src/test/org/apache/lucene/search/TestStressSort.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: lucene/java/trunk/src/test/org/apache/lucene/search/TestTermScorer.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/src/test/org/apache/lucene/search/TestTermScorer.java?rev=738219&r1=738218&r2=738219&view=diff
==============================================================================
--- lucene/java/trunk/src/test/org/apache/lucene/search/TestTermScorer.java (original)
+++ lucene/java/trunk/src/test/org/apache/lucene/search/TestTermScorer.java Tue Jan 27 20:15:21 2009
@@ -82,15 +82,19 @@
         //must call next first
 
 
-        ts.score(new HitCollector()
+        ts.score(new MultiReaderHitCollector()
         {
+            private int base = -1;
             public void collect(int doc, float score)
             {
-                docs.add(new TestHit(doc, score));
+                docs.add(new TestHit(doc + base, score));
                 assertTrue("score " + score + " is not greater than 0", score > 0);
                 assertTrue("Doc: " + doc + " does not equal: " + 0 +
                         " or doc does not equaal: " + 5, doc == 0 || doc == 5);
             }
+            public void setNextReader(IndexReader reader, int docBase) {
+              base = docBase;
+            }
         });
         assertTrue("docs Size: " + docs.size() + " is not: " + 2, docs.size() == 2);
         TestHit doc0 = (TestHit) docs.get(0);

Modified: lucene/java/trunk/src/test/org/apache/lucene/search/TestTimeLimitedCollector.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/src/test/org/apache/lucene/search/TestTimeLimitedCollector.java?rev=738219&r1=738218&r2=738219&view=diff
==============================================================================
--- lucene/java/trunk/src/test/org/apache/lucene/search/TestTimeLimitedCollector.java (original)
+++ lucene/java/trunk/src/test/org/apache/lucene/search/TestTimeLimitedCollector.java Tue Jan 27 20:15:21 2009
@@ -20,6 +20,7 @@
 import org.apache.lucene.analysis.WhitespaceAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriter.MaxFieldLength;
 import org.apache.lucene.queryParser.QueryParser;
@@ -125,6 +126,7 @@
       search(tlCollector);
       totalTLCResults = myHc.hitCount();
     } catch (Exception e) {
+      e.printStackTrace();
       assertTrue("Unexpected exception: "+e, false); //==fail
     }
     assertEquals( "Wrong number of results!", totalResults, totalTLCResults );
@@ -293,11 +295,12 @@
   }
   
   // counting hit collector that can slow down at collect().
-  private class MyHitCollector extends HitCollector
+  private class MyHitCollector extends MultiReaderHitCollector
   {
     private final BitSet bits = new BitSet();
     private int slowdown = 0;
     private int lastDocCollected = -1;
+    private int docBase = -1;
 
     /**
      * amount of time to wait on each collect to simulate a long iteration
@@ -307,6 +310,7 @@
     }
     
     public void collect( final int doc, final float score ) {
+      int docId = doc + docBase;
       if( slowdown > 0 ) {
         try {
           Thread.sleep(slowdown);
@@ -315,8 +319,9 @@
           System.out.println("caught " + x);
         }
       }
-      bits.set( doc );
-      lastDocCollected = doc;
+      assert docId >= 0: " base=" + docBase + " doc=" + doc;
+      bits.set( docId );
+      lastDocCollected = docId;
     }
     
     public int hitCount() {
@@ -326,6 +331,10 @@
     public int getLastDocCollected() {
       return lastDocCollected;
     }
+
+    public void setNextReader(IndexReader reader, int base) {
+      docBase = base;
+    }
     
   }
 



Mime
View raw message