| /* |
| * 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. |
| */ |
| |
| using System; |
| |
| using NUnit.Framework; |
| |
| using SimpleAnalyzer = Lucene.Net.Analysis.SimpleAnalyzer; |
| using Document = Lucene.Net.Documents.Document; |
| using Field = Lucene.Net.Documents.Field; |
| using IndexWriter = Lucene.Net.Index.IndexWriter; |
| using RAMDirectory = Lucene.Net.Store.RAMDirectory; |
| using LuceneTestCase = Lucene.Net.Util.LuceneTestCase; |
| |
| namespace Lucene.Net.Search |
| { |
| |
| [TestFixture] |
| public class BaseTestRangeFilter:LuceneTestCase |
| { |
| private void InitBlock() |
| { |
| signedIndex = new TestIndex(this, System.Int32.MaxValue, System.Int32.MinValue, true); |
| unsignedIndex = new TestIndex(this, System.Int32.MaxValue, 0, false); |
| } |
| |
| public const bool F = false; |
| public const bool T = true; |
| |
| protected internal System.Random rand; |
| |
| /// <summary> Collation interacts badly with hyphens -- collation produces different |
| /// ordering than Unicode code-point ordering -- so two indexes are created: |
| /// one which can't have negative random integers, for testing collated |
| /// ranges, and the other which can have negative random integers, for all |
| /// other tests. |
| /// </summary> |
| internal class TestIndex |
| { |
| private void InitBlock(BaseTestRangeFilter enclosingInstance) |
| { |
| this.enclosingInstance = enclosingInstance; |
| } |
| private BaseTestRangeFilter enclosingInstance; |
| public BaseTestRangeFilter Enclosing_Instance |
| { |
| get |
| { |
| return enclosingInstance; |
| } |
| |
| } |
| internal int maxR; |
| internal int minR; |
| internal bool allowNegativeRandomInts; |
| internal RAMDirectory index = new RAMDirectory(); |
| |
| internal TestIndex(BaseTestRangeFilter enclosingInstance, int minR, int maxR, bool allowNegativeRandomInts) |
| { |
| InitBlock(enclosingInstance); |
| this.minR = minR; |
| this.maxR = maxR; |
| this.allowNegativeRandomInts = allowNegativeRandomInts; |
| } |
| } |
| internal TestIndex signedIndex; |
| internal TestIndex unsignedIndex; |
| |
| internal int minId = 0; |
| internal int maxId = 10000; |
| |
| internal static readonly int intLength = System.Convert.ToString(System.Int32.MaxValue).Length; |
| |
| /// <summary> a simple padding function that should work with any int</summary> |
| public static System.String Pad(int n) |
| { |
| System.Text.StringBuilder b = new System.Text.StringBuilder(40); |
| System.String p = "0"; |
| if (n < 0) |
| { |
| p = "-"; |
| n = System.Int32.MaxValue + n + 1; |
| } |
| b.Append(p); |
| System.String s = System.Convert.ToString(n); |
| for (int i = s.Length; i <= intLength; i++) |
| { |
| b.Append("0"); |
| } |
| b.Append(s); |
| |
| return b.ToString(); |
| } |
| |
| public BaseTestRangeFilter(System.String name):base(name) |
| { |
| InitBlock(); |
| rand = NewRandom(); |
| Build(signedIndex); |
| Build(unsignedIndex); |
| } |
| public BaseTestRangeFilter() |
| { |
| InitBlock(); |
| rand = NewRandom(); |
| Build(signedIndex); |
| Build(unsignedIndex); |
| } |
| |
| private void Build(TestIndex index) |
| { |
| try |
| { |
| |
| /* build an index */ |
| IndexWriter writer = new IndexWriter(index.index, new SimpleAnalyzer(), T, IndexWriter.MaxFieldLength.LIMITED); |
| |
| for (int d = minId; d <= maxId; d++) |
| { |
| Document doc = new Document(); |
| doc.Add(new Field("id", Pad(d), Field.Store.YES, Field.Index.NOT_ANALYZED)); |
| int r = index.allowNegativeRandomInts ? rand.Next() : rand.Next(System.Int32.MaxValue); |
| if (index.maxR < r) |
| { |
| index.maxR = r; |
| } |
| if (r < index.minR) |
| { |
| index.minR = r; |
| } |
| doc.Add(new Field("rand", Pad(r), Field.Store.YES, Field.Index.NOT_ANALYZED)); |
| doc.Add(new Field("body", "body", Field.Store.YES, Field.Index.NOT_ANALYZED)); |
| writer.AddDocument(doc); |
| } |
| |
| writer.Optimize(); |
| writer.Close(); |
| } |
| catch (System.Exception e) |
| { |
| throw new System.SystemException("can't build index", e); |
| } |
| } |
| |
| [Test] |
| public virtual void TestPad() |
| { |
| |
| int[] tests = new int[]{- 9999999, - 99560, - 100, - 3, - 1, 0, 3, 9, 10, 1000, 999999999}; |
| for (int i = 0; i < tests.Length - 1; i++) |
| { |
| int a = tests[i]; |
| int b = tests[i + 1]; |
| System.String aa = Pad(a); |
| System.String bb = Pad(b); |
| System.String label = a + ":" + aa + " vs " + b + ":" + bb; |
| Assert.AreEqual(aa.Length, bb.Length, "length of " + label); |
| Assert.IsTrue(String.CompareOrdinal(aa, bb) < 0, "compare less than " + label); |
| } |
| } |
| } |
| } |