http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene45/TestLucene45DocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Codecs/Lucene45/TestLucene45DocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene45/TestLucene45DocValuesFormat.cs new file mode 100644 index 0000000..dc18580 --- /dev/null +++ b/src/Lucene.Net.Tests/Codecs/Lucene45/TestLucene45DocValuesFormat.cs @@ -0,0 +1,565 @@ +using NUnit.Framework; + +namespace Lucene.Net.Codecs.Lucene45 +{ + /* + * 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 BaseCompressingDocValuesFormatTestCase = Lucene.Net.Index.BaseCompressingDocValuesFormatTestCase; + using TestUtil = Lucene.Net.Util.TestUtil; + + /// <summary> + /// Tests Lucene45DocValuesFormat + /// </summary> + public class TestLucene45DocValuesFormat : BaseCompressingDocValuesFormatTestCase + { + private readonly Codec Codec_Renamed = TestUtil.AlwaysDocValuesFormat(new Lucene45DocValuesFormat()); + + protected override Codec Codec + { + get + { + return Codec_Renamed; + } + } + + #region BaseCompressingDocValuesFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestUniqueValuesCompression() + { + base.TestUniqueValuesCompression(); + } + + [Test] + public override void TestDateCompression() + { + base.TestDateCompression(); + } + + [Test] + public override void TestSingleBigValueCompression() + { + base.TestSingleBigValueCompression(); + } + + #endregion + + #region BaseDocValuesFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestOneNumber() + { + base.TestOneNumber(); + } + + [Test] + public override void TestOneFloat() + { + base.TestOneFloat(); + } + + [Test] + public override void TestTwoNumbers() + { + base.TestTwoNumbers(); + } + + [Test] + public override void TestTwoBinaryValues() + { + base.TestTwoBinaryValues(); + } + + [Test] + public override void TestTwoFieldsMixed() + { + base.TestTwoFieldsMixed(); + } + + [Test] + public override void TestThreeFieldsMixed() + { + base.TestThreeFieldsMixed(); + } + + [Test] + public override void TestThreeFieldsMixed2() + { + base.TestThreeFieldsMixed2(); + } + + [Test] + public override void TestTwoDocumentsNumeric() + { + base.TestTwoDocumentsNumeric(); + } + + [Test] + public override void TestTwoDocumentsMerged() + { + base.TestTwoDocumentsMerged(); + } + + [Test] + public override void TestBigNumericRange() + { + base.TestBigNumericRange(); + } + + [Test] + public override void TestBigNumericRange2() + { + base.TestBigNumericRange2(); + } + + [Test] + public override void TestBytes() + { + base.TestBytes(); + } + + [Test] + public override void TestBytesTwoDocumentsMerged() + { + base.TestBytesTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedBytes() + { + base.TestSortedBytes(); + } + + [Test] + public override void TestSortedBytesTwoDocuments() + { + base.TestSortedBytesTwoDocuments(); + } + + [Test] + public override void TestSortedBytesThreeDocuments() + { + base.TestSortedBytesThreeDocuments(); + } + + [Test] + public override void TestSortedBytesTwoDocumentsMerged() + { + base.TestSortedBytesTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedMergeAwayAllValues() + { + base.TestSortedMergeAwayAllValues(); + } + + [Test] + public override void TestBytesWithNewline() + { + base.TestBytesWithNewline(); + } + + [Test] + public override void TestMissingSortedBytes() + { + base.TestMissingSortedBytes(); + } + + [Test] + public override void TestSortedTermsEnum() + { + base.TestSortedTermsEnum(); + } + + [Test] + public override void TestEmptySortedBytes() + { + base.TestEmptySortedBytes(); + } + + [Test] + public override void TestEmptyBytes() + { + base.TestEmptyBytes(); + } + + [Test] + public override void TestVeryLargeButLegalBytes() + { + base.TestVeryLargeButLegalBytes(); + } + + [Test] + public override void TestVeryLargeButLegalSortedBytes() + { + base.TestVeryLargeButLegalSortedBytes(); + } + + [Test] + public override void TestCodecUsesOwnBytes() + { + base.TestCodecUsesOwnBytes(); + } + + [Test] + public override void TestCodecUsesOwnSortedBytes() + { + base.TestCodecUsesOwnSortedBytes(); + } + + [Test] + public override void TestCodecUsesOwnBytesEachTime() + { + base.TestCodecUsesOwnBytesEachTime(); + } + + [Test] + public override void TestCodecUsesOwnSortedBytesEachTime() + { + base.TestCodecUsesOwnSortedBytesEachTime(); + } + + /* + * Simple test case to show how to use the API + */ + [Test] + public override void TestDocValuesSimple() + { + base.TestDocValuesSimple(); + } + + [Test] + public override void TestRandomSortedBytes() + { + base.TestRandomSortedBytes(); + } + + [Test] + public override void TestBooleanNumericsVsStoredFields() + { + base.TestBooleanNumericsVsStoredFields(); + } + + [Test] + public override void TestByteNumericsVsStoredFields() + { + base.TestByteNumericsVsStoredFields(); + } + + [Test] + public override void TestByteMissingVsFieldCache() + { + base.TestByteMissingVsFieldCache(); + } + + [Test] + public override void TestShortNumericsVsStoredFields() + { + base.TestShortNumericsVsStoredFields(); + } + + [Test] + public override void TestShortMissingVsFieldCache() + { + base.TestShortMissingVsFieldCache(); + } + + [Test] + public override void TestIntNumericsVsStoredFields() + { + base.TestIntNumericsVsStoredFields(); + } + + [Test] + public override void TestIntMissingVsFieldCache() + { + base.TestIntMissingVsFieldCache(); + } + + [Test] + public override void TestLongNumericsVsStoredFields() + { + base.TestLongNumericsVsStoredFields(); + } + + [Test] + public override void TestLongMissingVsFieldCache() + { + base.TestLongMissingVsFieldCache(); + } + + [Test] + public override void TestBinaryFixedLengthVsStoredFields() + { + base.TestBinaryFixedLengthVsStoredFields(); + } + + [Test] + public override void TestBinaryVariableLengthVsStoredFields() + { + base.TestBinaryVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedFixedLengthVsStoredFields() + { + base.TestSortedFixedLengthVsStoredFields(); + } + + [Test] + public override void TestSortedFixedLengthVsFieldCache() + { + base.TestSortedFixedLengthVsFieldCache(); + } + + [Test] + public override void TestSortedVariableLengthVsFieldCache() + { + base.TestSortedVariableLengthVsFieldCache(); + } + + [Test] + public override void TestSortedVariableLengthVsStoredFields() + { + base.TestSortedVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetOneValue() + { + base.TestSortedSetOneValue(); + } + + [Test] + public override void TestSortedSetTwoFields() + { + base.TestSortedSetTwoFields(); + } + + [Test] + public override void TestSortedSetTwoDocumentsMerged() + { + base.TestSortedSetTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedSetTwoValues() + { + base.TestSortedSetTwoValues(); + } + + [Test] + public override void TestSortedSetTwoValuesUnordered() + { + base.TestSortedSetTwoValuesUnordered(); + } + + [Test] + public override void TestSortedSetThreeValuesTwoDocs() + { + base.TestSortedSetThreeValuesTwoDocs(); + } + + [Test] + public override void TestSortedSetTwoDocumentsLastMissing() + { + base.TestSortedSetTwoDocumentsLastMissing(); + } + + [Test] + public override void TestSortedSetTwoDocumentsLastMissingMerge() + { + base.TestSortedSetTwoDocumentsLastMissingMerge(); + } + + [Test] + public override void TestSortedSetTwoDocumentsFirstMissing() + { + base.TestSortedSetTwoDocumentsFirstMissing(); + } + + [Test] + public override void TestSortedSetTwoDocumentsFirstMissingMerge() + { + base.TestSortedSetTwoDocumentsFirstMissingMerge(); + } + + [Test] + public override void TestSortedSetMergeAwayAllValues() + { + base.TestSortedSetMergeAwayAllValues(); + } + + [Test] + public override void TestSortedSetTermsEnum() + { + base.TestSortedSetTermsEnum(); + } + + [Test] + public override void TestSortedSetFixedLengthVsStoredFields() + { + base.TestSortedSetFixedLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetVariableLengthVsStoredFields() + { + base.TestSortedSetVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetFixedLengthSingleValuedVsStoredFields() + { + base.TestSortedSetFixedLengthSingleValuedVsStoredFields(); + } + + [Test] + public override void TestSortedSetVariableLengthSingleValuedVsStoredFields() + { + base.TestSortedSetVariableLengthSingleValuedVsStoredFields(); + } + + [Test] + public override void TestSortedSetFixedLengthVsUninvertedField() + { + base.TestSortedSetFixedLengthVsUninvertedField(); + } + + [Test] + public override void TestSortedSetVariableLengthVsUninvertedField() + { + base.TestSortedSetVariableLengthVsUninvertedField(); + } + + [Test] + public override void TestGCDCompression() + { + base.TestGCDCompression(); + } + + [Test] + public override void TestZeros() + { + base.TestZeros(); + } + + [Test] + public override void TestZeroOrMin() + { + base.TestZeroOrMin(); + } + + [Test] + public override void TestTwoNumbersOneMissing() + { + base.TestTwoNumbersOneMissing(); + } + + [Test] + public override void TestTwoNumbersOneMissingWithMerging() + { + base.TestTwoNumbersOneMissingWithMerging(); + } + + [Test] + public override void TestThreeNumbersOneMissingWithMerging() + { + base.TestThreeNumbersOneMissingWithMerging(); + } + + [Test] + public override void TestTwoBytesOneMissing() + { + base.TestTwoBytesOneMissing(); + } + + [Test] + public override void TestTwoBytesOneMissingWithMerging() + { + base.TestTwoBytesOneMissingWithMerging(); + } + + [Test] + public override void TestThreeBytesOneMissingWithMerging() + { + base.TestThreeBytesOneMissingWithMerging(); + } + + // LUCENE-4853 + [Test] + public override void TestHugeBinaryValues() + { + base.TestHugeBinaryValues(); + } + + // TODO: get this out of here and into the deprecated codecs (4.0, 4.2) + [Test] + public override void TestHugeBinaryValueLimit() + { + base.TestHugeBinaryValueLimit(); + } + + /// <summary> + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// </summary> + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// <summary> + /// Tests dv against stored fields with threads (all types + missing) + /// </summary> + [Test] + public override void TestThreads2() + { + base.TestThreads2(); + } + + // LUCENE-5218 + [Test] + public override void TestEmptyBinaryValueOnPageSizes() + { + base.TestEmptyBinaryValueOnPageSizes(); + } + + #endregion + + #region BaseIndexFileFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestMergeStability() + { + base.TestMergeStability(); + } + + #endregion + } +} \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs new file mode 100644 index 0000000..ddb4527 --- /dev/null +++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs @@ -0,0 +1,658 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using Lucene.Net.Documents; + +namespace Lucene.Net.Codecs.PerField +{ + using Lucene.Net.Index; + using NUnit.Framework; + + /* + * 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 Analyzer = Lucene.Net.Analysis.Analyzer; + using BaseDocValuesFormatTestCase = Lucene.Net.Index.BaseDocValuesFormatTestCase; + using BinaryDocValues = Lucene.Net.Index.BinaryDocValues; + using BinaryDocValuesField = BinaryDocValuesField; + using BytesRef = Lucene.Net.Util.BytesRef; + using Directory = Lucene.Net.Store.Directory; + using DirectoryReader = Lucene.Net.Index.DirectoryReader; + using Document = Documents.Document; + using Field = Field; + using IndexReader = Lucene.Net.Index.IndexReader; + using IndexSearcher = Lucene.Net.Search.IndexSearcher; + using IndexWriter = Lucene.Net.Index.IndexWriter; + using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig; + using Lucene46Codec = Lucene.Net.Codecs.Lucene46.Lucene46Codec; + using MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer; + using NumericDocValues = Lucene.Net.Index.NumericDocValues; + using NumericDocValuesField = NumericDocValuesField; + using Query = Lucene.Net.Search.Query; + using RandomCodec = Lucene.Net.Index.RandomCodec; + using Term = Lucene.Net.Index.Term; + using TermQuery = Lucene.Net.Search.TermQuery; + using TestUtil = Lucene.Net.Util.TestUtil; + using TopDocs = Lucene.Net.Search.TopDocs; + + /// <summary> + /// Basic tests of PerFieldDocValuesFormat + /// </summary> + [TestFixture] + public class TestPerFieldDocValuesFormat : BaseDocValuesFormatTestCase + { + private Codec Codec_Renamed; + + [SetUp] + public override void SetUp() + { + Codec_Renamed = new RandomCodec(new Random(Random().Next()), new HashSet<string>()); + base.SetUp(); + } + + protected override Codec Codec + { + get + { + return Codec_Renamed; + } + } + + protected internal override bool CodecAcceptsHugeBinaryValues(string field) + { + return TestUtil.FieldSupportsHugeBinaryDocValues(field); + } + + // just a simple trivial test + // TODO: we should come up with a test that somehow checks that segment suffix + // is respected by all codec apis (not just docvalues and postings) + [Test] + public virtual void TestTwoFieldsTwoFormats() + { + Analyzer analyzer = new MockAnalyzer(Random()); + + Directory directory = NewDirectory(); + // we don't use RandomIndexWriter because it might add more docvalues than we expect !!!!1 + IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer); + DocValuesFormat fast = DocValuesFormat.ForName("Lucene45"); + DocValuesFormat slow = DocValuesFormat.ForName("Lucene45"); + iwc.SetCodec(new Lucene46CodecAnonymousInnerClassHelper(this, fast, slow)); + IndexWriter iwriter = new IndexWriter(directory, iwc); + Document doc = new Document(); + string longTerm = "longtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongterm"; + string text = "this is the text to be indexed. " + longTerm; + doc.Add(NewTextField("fieldname", text, Field.Store.YES)); + doc.Add(new NumericDocValuesField("dv1", 5)); + doc.Add(new BinaryDocValuesField("dv2", new BytesRef("hello world"))); + iwriter.AddDocument(doc); + iwriter.Dispose(); + + // Now search the index: + IndexReader ireader = DirectoryReader.Open(directory); // read-only=true + IndexSearcher isearcher = NewSearcher(ireader); + + Assert.AreEqual(1, isearcher.Search(new TermQuery(new Term("fieldname", longTerm)), 1).TotalHits); + Query query = new TermQuery(new Term("fieldname", "text")); + TopDocs hits = isearcher.Search(query, null, 1); + Assert.AreEqual(1, hits.TotalHits); + BytesRef scratch = new BytesRef(); + // Iterate through the results: + for (int i = 0; i < hits.ScoreDocs.Length; i++) + { + Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc); + Assert.AreEqual(text, hitDoc.Get("fieldname")); + Debug.Assert(ireader.Leaves.Count == 1); + NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv1"); + Assert.AreEqual(5, dv.Get(hits.ScoreDocs[i].Doc)); + BinaryDocValues dv2 = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv2"); + dv2.Get(hits.ScoreDocs[i].Doc, scratch); + Assert.AreEqual(new BytesRef("hello world"), scratch); + } + + ireader.Dispose(); + directory.Dispose(); + } + + private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec + { + private readonly TestPerFieldDocValuesFormat OuterInstance; + + private DocValuesFormat Fast; + private DocValuesFormat Slow; + + public Lucene46CodecAnonymousInnerClassHelper(TestPerFieldDocValuesFormat outerInstance, DocValuesFormat fast, DocValuesFormat slow) + { + this.OuterInstance = outerInstance; + this.Fast = fast; + this.Slow = slow; + } + + public override DocValuesFormat GetDocValuesFormatForField(string field) + { + if ("dv1".Equals(field)) + { + return Fast; + } + else + { + return Slow; + } + } + } + + + #region BaseDocValuesFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestOneNumber() + { + base.TestOneNumber(); + } + + [Test] + public override void TestOneFloat() + { + base.TestOneFloat(); + } + + [Test] + public override void TestTwoNumbers() + { + base.TestTwoNumbers(); + } + + [Test] + public override void TestTwoBinaryValues() + { + base.TestTwoBinaryValues(); + } + + [Test] + public override void TestTwoFieldsMixed() + { + base.TestTwoFieldsMixed(); + } + + [Test] + public override void TestThreeFieldsMixed() + { + base.TestThreeFieldsMixed(); + } + + [Test] + public override void TestThreeFieldsMixed2() + { + base.TestThreeFieldsMixed2(); + } + + [Test] + public override void TestTwoDocumentsNumeric() + { + base.TestTwoDocumentsNumeric(); + } + + [Test] + public override void TestTwoDocumentsMerged() + { + base.TestTwoDocumentsMerged(); + } + + [Test] + public override void TestBigNumericRange() + { + base.TestBigNumericRange(); + } + + [Test] + public override void TestBigNumericRange2() + { + base.TestBigNumericRange2(); + } + + [Test] + public override void TestBytes() + { + base.TestBytes(); + } + + [Test] + public override void TestBytesTwoDocumentsMerged() + { + base.TestBytesTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedBytes() + { + base.TestSortedBytes(); + } + + [Test] + public override void TestSortedBytesTwoDocuments() + { + base.TestSortedBytesTwoDocuments(); + } + + [Test] + public override void TestSortedBytesThreeDocuments() + { + base.TestSortedBytesThreeDocuments(); + } + + [Test] + public override void TestSortedBytesTwoDocumentsMerged() + { + base.TestSortedBytesTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedMergeAwayAllValues() + { + base.TestSortedMergeAwayAllValues(); + } + + [Test] + public override void TestBytesWithNewline() + { + base.TestBytesWithNewline(); + } + + [Test] + public override void TestMissingSortedBytes() + { + base.TestMissingSortedBytes(); + } + + [Test] + public override void TestSortedTermsEnum() + { + base.TestSortedTermsEnum(); + } + + [Test] + public override void TestEmptySortedBytes() + { + base.TestEmptySortedBytes(); + } + + [Test] + public override void TestEmptyBytes() + { + base.TestEmptyBytes(); + } + + [Test] + public override void TestVeryLargeButLegalBytes() + { + base.TestVeryLargeButLegalBytes(); + } + + [Test] + public override void TestVeryLargeButLegalSortedBytes() + { + base.TestVeryLargeButLegalSortedBytes(); + } + + [Test] + public override void TestCodecUsesOwnBytes() + { + base.TestCodecUsesOwnBytes(); + } + + [Test] + public override void TestCodecUsesOwnSortedBytes() + { + base.TestCodecUsesOwnSortedBytes(); + } + + [Test] + public override void TestCodecUsesOwnBytesEachTime() + { + base.TestCodecUsesOwnBytesEachTime(); + } + + [Test] + public override void TestCodecUsesOwnSortedBytesEachTime() + { + base.TestCodecUsesOwnSortedBytesEachTime(); + } + + /* + * Simple test case to show how to use the API + */ + [Test] + public override void TestDocValuesSimple() + { + base.TestDocValuesSimple(); + } + + [Test] + public override void TestRandomSortedBytes() + { + base.TestRandomSortedBytes(); + } + + [Test] + public override void TestBooleanNumericsVsStoredFields() + { + base.TestBooleanNumericsVsStoredFields(); + } + + [Test] + public override void TestByteNumericsVsStoredFields() + { + base.TestByteNumericsVsStoredFields(); + } + + [Test] + public override void TestByteMissingVsFieldCache() + { + base.TestByteMissingVsFieldCache(); + } + + [Test] + public override void TestShortNumericsVsStoredFields() + { + base.TestShortNumericsVsStoredFields(); + } + + [Test] + public override void TestShortMissingVsFieldCache() + { + base.TestShortMissingVsFieldCache(); + } + + [Test] + public override void TestIntNumericsVsStoredFields() + { + base.TestIntNumericsVsStoredFields(); + } + + [Test] + public override void TestIntMissingVsFieldCache() + { + base.TestIntMissingVsFieldCache(); + } + + [Test] + public override void TestLongNumericsVsStoredFields() + { + base.TestLongNumericsVsStoredFields(); + } + + [Test] + public override void TestLongMissingVsFieldCache() + { + base.TestLongMissingVsFieldCache(); + } + + [Test] + public override void TestBinaryFixedLengthVsStoredFields() + { + base.TestBinaryFixedLengthVsStoredFields(); + } + + [Test] + public override void TestBinaryVariableLengthVsStoredFields() + { + base.TestBinaryVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedFixedLengthVsStoredFields() + { + base.TestSortedFixedLengthVsStoredFields(); + } + + [Test] + public override void TestSortedFixedLengthVsFieldCache() + { + base.TestSortedFixedLengthVsFieldCache(); + } + + [Test] + public override void TestSortedVariableLengthVsFieldCache() + { + base.TestSortedVariableLengthVsFieldCache(); + } + + [Test] + public override void TestSortedVariableLengthVsStoredFields() + { + base.TestSortedVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetOneValue() + { + base.TestSortedSetOneValue(); + } + + [Test] + public override void TestSortedSetTwoFields() + { + base.TestSortedSetTwoFields(); + } + + [Test] + public override void TestSortedSetTwoDocumentsMerged() + { + base.TestSortedSetTwoDocumentsMerged(); + } + + [Test] + public override void TestSortedSetTwoValues() + { + base.TestSortedSetTwoValues(); + } + + [Test] + public override void TestSortedSetTwoValuesUnordered() + { + base.TestSortedSetTwoValuesUnordered(); + } + + [Test] + public override void TestSortedSetThreeValuesTwoDocs() + { + base.TestSortedSetThreeValuesTwoDocs(); + } + + [Test] + public override void TestSortedSetTwoDocumentsLastMissing() + { + base.TestSortedSetTwoDocumentsLastMissing(); + } + + [Test] + public override void TestSortedSetTwoDocumentsLastMissingMerge() + { + base.TestSortedSetTwoDocumentsLastMissingMerge(); + } + + [Test] + public override void TestSortedSetTwoDocumentsFirstMissing() + { + base.TestSortedSetTwoDocumentsFirstMissing(); + } + + [Test] + public override void TestSortedSetTwoDocumentsFirstMissingMerge() + { + base.TestSortedSetTwoDocumentsFirstMissingMerge(); + } + + [Test] + public override void TestSortedSetMergeAwayAllValues() + { + base.TestSortedSetMergeAwayAllValues(); + } + + [Test] + public override void TestSortedSetTermsEnum() + { + base.TestSortedSetTermsEnum(); + } + + [Test] + public override void TestSortedSetFixedLengthVsStoredFields() + { + base.TestSortedSetFixedLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetVariableLengthVsStoredFields() + { + base.TestSortedSetVariableLengthVsStoredFields(); + } + + [Test] + public override void TestSortedSetFixedLengthSingleValuedVsStoredFields() + { + base.TestSortedSetFixedLengthSingleValuedVsStoredFields(); + } + + [Test] + public override void TestSortedSetVariableLengthSingleValuedVsStoredFields() + { + base.TestSortedSetVariableLengthSingleValuedVsStoredFields(); + } + + [Test] + public override void TestSortedSetFixedLengthVsUninvertedField() + { + base.TestSortedSetFixedLengthVsUninvertedField(); + } + + [Test] + public override void TestSortedSetVariableLengthVsUninvertedField() + { + base.TestSortedSetVariableLengthVsUninvertedField(); + } + + [Test] + public override void TestGCDCompression() + { + base.TestGCDCompression(); + } + + [Test] + public override void TestZeros() + { + base.TestZeros(); + } + + [Test] + public override void TestZeroOrMin() + { + base.TestZeroOrMin(); + } + + [Test] + public override void TestTwoNumbersOneMissing() + { + base.TestTwoNumbersOneMissing(); + } + + [Test] + public override void TestTwoNumbersOneMissingWithMerging() + { + base.TestTwoNumbersOneMissingWithMerging(); + } + + [Test] + public override void TestThreeNumbersOneMissingWithMerging() + { + base.TestThreeNumbersOneMissingWithMerging(); + } + + [Test] + public override void TestTwoBytesOneMissing() + { + base.TestTwoBytesOneMissing(); + } + + [Test] + public override void TestTwoBytesOneMissingWithMerging() + { + base.TestTwoBytesOneMissingWithMerging(); + } + + [Test] + public override void TestThreeBytesOneMissingWithMerging() + { + base.TestThreeBytesOneMissingWithMerging(); + } + + // LUCENE-4853 + [Test] + public override void TestHugeBinaryValues() + { + base.TestHugeBinaryValues(); + } + + // TODO: get this out of here and into the deprecated codecs (4.0, 4.2) + [Test] + public override void TestHugeBinaryValueLimit() + { + base.TestHugeBinaryValueLimit(); + } + + /// <summary> + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// </summary> + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// <summary> + /// Tests dv against stored fields with threads (all types + missing) + /// </summary> + [Test] + public override void TestThreads2() + { + base.TestThreads2(); + } + + // LUCENE-5218 + [Test] + public override void TestEmptyBinaryValueOnPageSizes() + { + base.TestEmptyBinaryValueOnPageSizes(); + } + + #endregion + + #region BaseIndexFileFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestMergeStability() + { + base.TestMergeStability(); + } + + #endregion + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat.cs new file mode 100644 index 0000000..a6d5dd2 --- /dev/null +++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat.cs @@ -0,0 +1,100 @@ +using System; +using System.Collections.Generic; + +namespace Lucene.Net.Codecs.PerField +{ + using NUnit.Framework; + + /* + * 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 BasePostingsFormatTestCase = Lucene.Net.Index.BasePostingsFormatTestCase; + using RandomCodec = Lucene.Net.Index.RandomCodec; + + /// <summary> + /// Basic tests of PerFieldPostingsFormat + /// </summary> + [TestFixture] + public class TestPerFieldPostingsFormat : BasePostingsFormatTestCase + { + protected override Codec Codec + { + get + { + return new RandomCodec(new Random(Random().Next()), new HashSet<string>()); + } + } + + [Test] + public override void TestMergeStability() + { + //LUCENE TO-DO + AssumeTrue("The MockRandom PF randomizes content on the fly, so we can't check it", false); + } + + + #region BasePostingsFormatTestCase + // LUCENENET NOTE: Tests in an abstract base class are not pulled into the correct + // context in Visual Studio. This fixes that with the minimum amount of code necessary + // to run them in the correct context without duplicating all of the tests. + + [Test] + public override void TestDocsOnly() + { + base.TestDocsOnly(); + } + + [Test] + public override void TestDocsAndFreqs() + { + base.TestDocsAndFreqs(); + } + + [Test] + public override void TestDocsAndFreqsAndPositions() + { + base.TestDocsAndFreqsAndPositions(); + } + + [Test] + public override void TestDocsAndFreqsAndPositionsAndPayloads() + { + base.TestDocsAndFreqsAndPositionsAndPayloads(); + } + + [Test] + public override void TestDocsAndFreqsAndPositionsAndOffsets() + { + base.TestDocsAndFreqsAndPositionsAndOffsets(); + } + + [Test] + public override void TestDocsAndFreqsAndPositionsAndOffsetsAndPayloads() + { + base.TestDocsAndFreqsAndPositionsAndOffsetsAndPayloads(); + } + + [Test] + public override void TestRandom() + { + base.TestRandom(); + } + + #endregion + + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs new file mode 100644 index 0000000..f758532 --- /dev/null +++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs @@ -0,0 +1,372 @@ +using System; +using Lucene.Net.Documents; +using Lucene.Net.Codecs.Lucene41; +using Lucene.Net.Codecs.Lucene46; +using Lucene.Net.Codecs.SimpleText; +using Lucene.Net.Codecs.Pulsing; +using Lucene.Net.Codecs.MockSep; +using Lucene.Net.Util; +using Lucene.Net.Index; +using Lucene.Net.Search; +using Lucene.Net.Analysis; +using Lucene.Net.Randomized.Generators; +using NUnit.Framework; +using Lucene.Net.Store; + +namespace Lucene.Net.Codecs.PerField +{ + /* + * 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 Document = Documents.Document; + + //TODO: would be better in this test to pull termsenums and instanceof or something? + // this way we can verify PFPF is doing the right thing. + // for now we do termqueries. + [TestFixture] + public class TestPerFieldPostingsFormat2 : LuceneTestCase + { + private IndexWriter NewWriter(Directory dir, IndexWriterConfig conf) + { + LogDocMergePolicy logByteSizeMergePolicy = new LogDocMergePolicy(); + logByteSizeMergePolicy.NoCFSRatio = 0.0; // make sure we use plain + // files + conf.SetMergePolicy(logByteSizeMergePolicy); + + IndexWriter writer = new IndexWriter(dir, conf); + return writer; + } + + private void AddDocs(IndexWriter writer, int numDocs) + { + for (int i = 0; i < numDocs; i++) + { + Document doc = new Document(); + doc.Add(NewTextField("content", "aaa", Field.Store.NO)); + writer.AddDocument(doc); + } + } + + private void AddDocs2(IndexWriter writer, int numDocs) + { + for (int i = 0; i < numDocs; i++) + { + Document doc = new Document(); + doc.Add(NewTextField("content", "bbb", Field.Store.NO)); + writer.AddDocument(doc); + } + } + + private void AddDocs3(IndexWriter writer, int numDocs) + { + for (int i = 0; i < numDocs; i++) + { + Document doc = new Document(); + doc.Add(NewTextField("content", "ccc", Field.Store.NO)); + doc.Add(NewStringField("id", "" + i, Field.Store.YES)); + writer.AddDocument(doc); + } + } + + /// <summary> + /// Test that heterogeneous index segments are merge successfully + /// </summary> + [Test] + public virtual void TestMergeUnusedPerFieldCodec() + { + Directory dir = NewDirectory(); + IndexWriterConfig iwconf = NewIndexWriterConfig(TEST_VERSION_CURRENT, + new MockAnalyzer(Random())).SetOpenMode(OpenMode.CREATE).SetCodec(new MockCodec()); + IndexWriter writer = NewWriter(dir, iwconf); + AddDocs(writer, 10); + writer.Commit(); + AddDocs3(writer, 10); + writer.Commit(); + AddDocs2(writer, 10); + writer.Commit(); + Assert.AreEqual(30, writer.MaxDoc); + TestUtil.CheckIndex(dir); + writer.ForceMerge(1); + Assert.AreEqual(30, writer.MaxDoc); + writer.Dispose(); + dir.Dispose(); + } + + /// <summary> + /// Test that heterogeneous index segments are merged sucessfully + /// </summary> + // TODO: not sure this test is that great, we should probably peek inside PerFieldPostingsFormat or something?! + [Test] + public virtual void TestChangeCodecAndMerge() + { + Directory dir = NewDirectory(); + if (VERBOSE) + { + Console.WriteLine("TEST: make new index"); + } + IndexWriterConfig iwconf = NewIndexWriterConfig(TEST_VERSION_CURRENT, + new MockAnalyzer(Random())).SetOpenMode(OpenMode.CREATE).SetCodec(new MockCodec()); + iwconf.SetMaxBufferedDocs(IndexWriterConfig.DISABLE_AUTO_FLUSH); + // ((LogMergePolicy)iwconf.getMergePolicy()).setMergeFactor(10); + IndexWriter writer = NewWriter(dir, iwconf); + + AddDocs(writer, 10); + writer.Commit(); + AssertQuery(new Term("content", "aaa"), dir, 10); + if (VERBOSE) + { + Console.WriteLine("TEST: addDocs3"); + } + AddDocs3(writer, 10); + writer.Commit(); + writer.Dispose(); + + AssertQuery(new Term("content", "ccc"), dir, 10); + AssertQuery(new Term("content", "aaa"), dir, 10); + Codec codec = iwconf.Codec; + + iwconf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())) + .SetOpenMode(OpenMode.APPEND).SetCodec(codec); + // ((LogMergePolicy)iwconf.getMergePolicy()).setNoCFSRatio(0.0); + // ((LogMergePolicy)iwconf.getMergePolicy()).setMergeFactor(10); + iwconf.SetMaxBufferedDocs(IndexWriterConfig.DISABLE_AUTO_FLUSH); + + iwconf.SetCodec(new MockCodec2()); // uses standard for field content + writer = NewWriter(dir, iwconf); + // swap in new codec for currently written segments + if (VERBOSE) + { + Console.WriteLine("TEST: add docs w/ Standard codec for content field"); + } + AddDocs2(writer, 10); + writer.Commit(); + codec = iwconf.Codec; + Assert.AreEqual(30, writer.MaxDoc); + AssertQuery(new Term("content", "bbb"), dir, 10); + AssertQuery(new Term("content", "ccc"), dir, 10); //// + AssertQuery(new Term("content", "aaa"), dir, 10); + + if (VERBOSE) + { + Console.WriteLine("TEST: add more docs w/ new codec"); + } + AddDocs2(writer, 10); + writer.Commit(); + AssertQuery(new Term("content", "ccc"), dir, 10); + AssertQuery(new Term("content", "bbb"), dir, 20); + AssertQuery(new Term("content", "aaa"), dir, 10); + Assert.AreEqual(40, writer.MaxDoc); + + if (VERBOSE) + { + Console.WriteLine("TEST: now optimize"); + } + writer.ForceMerge(1); + Assert.AreEqual(40, writer.MaxDoc); + writer.Dispose(); + AssertQuery(new Term("content", "ccc"), dir, 10); + AssertQuery(new Term("content", "bbb"), dir, 20); + AssertQuery(new Term("content", "aaa"), dir, 10); + + dir.Dispose(); + } + + public virtual void AssertQuery(Term t, Directory dir, int num) + { + if (VERBOSE) + { + Console.WriteLine("\nTEST: assertQuery " + t); + } + IndexReader reader = DirectoryReader.Open(dir, 1); + IndexSearcher searcher = NewSearcher(reader); + TopDocs search = searcher.Search(new TermQuery(t), num + 10); + Assert.AreEqual(num, search.TotalHits); + reader.Dispose(); + } + + private class MockCodec : Lucene46Codec + { + internal readonly PostingsFormat Lucene40 = new Lucene41PostingsFormat(); + internal readonly PostingsFormat SimpleText = new SimpleTextPostingsFormat(); + internal readonly PostingsFormat MockSep = new MockSepPostingsFormat(); + + public override PostingsFormat GetPostingsFormatForField(string field) + { + if (field.Equals("id")) + { + return SimpleText; + } + else if (field.Equals("content")) + { + return MockSep; + } + else + { + return Lucene40; + } + } + } + + private class MockCodec2 : Lucene46Codec + { + internal readonly PostingsFormat Lucene40 = new Lucene41PostingsFormat(); + internal readonly PostingsFormat SimpleText = new SimpleTextPostingsFormat(); + + public override PostingsFormat GetPostingsFormatForField(string field) + { + if (field.Equals("id")) + { + return SimpleText; + } + else + { + return Lucene40; + } + } + } + + /// <summary> + /// Test per field codec support - adding fields with random codecs + /// </summary> + [Test] + public virtual void TestStressPerFieldCodec() + { + Directory dir = NewDirectory(Random()); + const int docsPerRound = 97; + int numRounds = AtLeast(1); + for (int i = 0; i < numRounds; i++) + { + int num = TestUtil.NextInt(Random(), 30, 60); + IndexWriterConfig config = NewIndexWriterConfig(Random(), TEST_VERSION_CURRENT, new MockAnalyzer(Random())); + config.SetOpenMode(OpenMode.CREATE_OR_APPEND); + IndexWriter writer = NewWriter(dir, config); + for (int j = 0; j < docsPerRound; j++) + { + Document doc = new Document(); + for (int k = 0; k < num; k++) + { + FieldType customType = new FieldType(TextField.TYPE_NOT_STORED); + customType.IsTokenized = Random().NextBoolean(); + customType.OmitNorms = Random().NextBoolean(); + Field field = NewField("" + k, TestUtil.RandomRealisticUnicodeString(Random(), 128), customType); + doc.Add(field); + } + writer.AddDocument(doc); + } + if (Random().NextBoolean()) + { + writer.ForceMerge(1); + } + writer.Commit(); + Assert.AreEqual((i + 1) * docsPerRound, writer.MaxDoc); + writer.Dispose(); + } + dir.Dispose(); + } + + [Test] + public virtual void TestSameCodecDifferentInstance() + { + Codec codec = new Lucene46CodecAnonymousInnerClassHelper(this); + DoTestMixedPostings(codec); + } + + private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec + { + private readonly TestPerFieldPostingsFormat2 OuterInstance; + + public Lucene46CodecAnonymousInnerClassHelper(TestPerFieldPostingsFormat2 outerInstance) + { + this.OuterInstance = outerInstance; + } + + public override PostingsFormat GetPostingsFormatForField(string field) + { + if ("id".Equals(field)) + { + return new Pulsing41PostingsFormat(1); + } + else if ("date".Equals(field)) + { + return new Pulsing41PostingsFormat(1); + } + else + { + return base.GetPostingsFormatForField(field); + } + } + } + + [Test] + public virtual void TestSameCodecDifferentParams() + { + Codec codec = new Lucene46CodecAnonymousInnerClassHelper2(this); + DoTestMixedPostings(codec); + } + + private class Lucene46CodecAnonymousInnerClassHelper2 : Lucene46Codec + { + private readonly TestPerFieldPostingsFormat2 OuterInstance; + + public Lucene46CodecAnonymousInnerClassHelper2(TestPerFieldPostingsFormat2 outerInstance) + { + this.OuterInstance = outerInstance; + } + + public override PostingsFormat GetPostingsFormatForField(string field) + { + if ("id".Equals(field)) + { + return new Pulsing41PostingsFormat(1); + } + else if ("date".Equals(field)) + { + return new Pulsing41PostingsFormat(2); + } + else + { + return base.GetPostingsFormatForField(field); + } + } + } + + private void DoTestMixedPostings(Codec codec) + { + Directory dir = NewDirectory(); + IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())); + iwc.SetCodec(codec); + RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, iwc); + Document doc = new Document(); + FieldType ft = new FieldType(TextField.TYPE_NOT_STORED); + // turn on vectors for the checkindex cross-check + ft.StoreTermVectors = true; + ft.StoreTermVectorOffsets = true; + ft.StoreTermVectorPositions = true; + Field idField = new Field("id", "", ft); + Field dateField = new Field("date", "", ft); + doc.Add(idField); + doc.Add(dateField); + for (int i = 0; i < 100; i++) + { + idField.SetStringValue(Convert.ToString(Random().Next(50))); + dateField.SetStringValue(Convert.ToString(Random().Next(100))); + iw.AddDocument(doc); + } + iw.Dispose(); + dir.Dispose(); // checkindex + } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Document/TestBinaryDocument.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Document/TestBinaryDocument.cs b/src/Lucene.Net.Tests/Document/TestBinaryDocument.cs new file mode 100644 index 0000000..839fa30 --- /dev/null +++ b/src/Lucene.Net.Tests/Document/TestBinaryDocument.cs @@ -0,0 +1,122 @@ +using Lucene.Net.Support; +using NUnit.Framework; +using System; +using System.Text; + +namespace Lucene.Net.Documents +{ + /* + * 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 BytesRef = Lucene.Net.Util.BytesRef; + using Directory = Lucene.Net.Store.Directory; + using IIndexableField = Lucene.Net.Index.IIndexableField; + using IndexReader = Lucene.Net.Index.IndexReader; + using LuceneTestCase = Lucene.Net.Util.LuceneTestCase; + using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter; + + /// <summary> + /// Tests <seealso cref="Document"/> class. + /// </summary> + [TestFixture] + public class TestBinaryDocument : LuceneTestCase + { + internal string BinaryValStored = "this text will be stored as a byte array in the index"; + internal string BinaryValCompressed = "this text will be also stored and compressed as a byte array in the index"; + + [Test] + public virtual void TestBinaryFieldInIndex() + { + FieldType ft = new FieldType(); + ft.IsStored = true; + IIndexableField binaryFldStored = new StoredField("binaryStored", System.Text.UTF8Encoding.UTF8.GetBytes(BinaryValStored)); + IIndexableField stringFldStored = new Field("stringStored", BinaryValStored, ft); + + Documents.Document doc = new Documents.Document(); + + doc.Add(binaryFldStored); + + doc.Add(stringFldStored); + + /// <summary> + /// test for field count </summary> + Assert.AreEqual(2, doc.Fields.Count); + + /// <summary> + /// add the doc to a ram index </summary> + Directory dir = NewDirectory(); + Random r = Random(); + RandomIndexWriter writer = new RandomIndexWriter(r, dir, Similarity, TimeZone); + writer.AddDocument(doc); + + /// <summary> + /// open a reader and fetch the document </summary> + IndexReader reader = writer.Reader; + Documents.Document docFromReader = reader.Document(0); + Assert.IsTrue(docFromReader != null); + + /// <summary> + /// fetch the binary stored field and compare it's content with the original one </summary> + BytesRef bytes = docFromReader.GetBinaryValue("binaryStored"); + Assert.IsNotNull(bytes); + + string binaryFldStoredTest = Encoding.UTF8.GetString((byte[])(Array)bytes.Bytes).Substring(bytes.Offset, bytes.Length); + //new string(bytes.Bytes, bytes.Offset, bytes.Length, IOUtils.CHARSET_UTF_8); + Assert.IsTrue(binaryFldStoredTest.Equals(BinaryValStored)); + + /// <summary> + /// fetch the string field and compare it's content with the original one </summary> + string stringFldStoredTest = docFromReader.Get("stringStored"); + Assert.IsTrue(stringFldStoredTest.Equals(BinaryValStored)); + + writer.Dispose(); + reader.Dispose(); + dir.Dispose(); + } + + [Test] + public virtual void TestCompressionTools() + { + IIndexableField binaryFldCompressed = new StoredField("binaryCompressed", CompressionTools.Compress(BinaryValCompressed.GetBytes(Encoding.UTF8))); + IIndexableField stringFldCompressed = new StoredField("stringCompressed", CompressionTools.CompressString(BinaryValCompressed)); + + var doc = new Documents.Document {binaryFldCompressed, stringFldCompressed}; + + using (Directory dir = NewDirectory()) + using (RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone)) + { + writer.AddDocument(doc); + + using (IndexReader reader = writer.Reader) + { + Documents.Document docFromReader = reader.Document(0); + Assert.IsTrue(docFromReader != null); + + string binaryFldCompressedTest = + Encoding.UTF8.GetString( + CompressionTools.Decompress(docFromReader.GetBinaryValue("binaryCompressed"))); + //new string(CompressionTools.Decompress(docFromReader.GetBinaryValue("binaryCompressed")), IOUtils.CHARSET_UTF_8); + Assert.IsTrue(binaryFldCompressedTest.Equals(BinaryValCompressed)); + Assert.IsTrue( + CompressionTools.DecompressString(docFromReader.GetBinaryValue("stringCompressed")) + .Equals(BinaryValCompressed)); + } + + } + } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Document/TestDateTools.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/Document/TestDateTools.cs b/src/Lucene.Net.Tests/Document/TestDateTools.cs new file mode 100644 index 0000000..8a4d823 --- /dev/null +++ b/src/Lucene.Net.Tests/Document/TestDateTools.cs @@ -0,0 +1,244 @@ +using Lucene.Net.Util; +using NUnit.Framework; +using System; +using System.Globalization; + +namespace Lucene.Net.Documents +{ + /* + * 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. + */ + + [TestFixture] + public class TestDateTools : LuceneTestCase + { + //public TestRule TestRules = RuleChain.outerRule(new SystemPropertiesRestoreRule()); + + [Test] + public virtual void TestStringToDate() + { + DateTime d = default(DateTime); + d = DateTools.StringToDate("2004"); + Assert.AreEqual("2004-01-01 00:00:00:000", IsoFormat(d)); + d = DateTools.StringToDate("20040705"); + Assert.AreEqual("2004-07-05 00:00:00:000", IsoFormat(d)); + d = DateTools.StringToDate("200407050910"); + Assert.AreEqual("2004-07-05 09:10:00:000", IsoFormat(d)); + d = DateTools.StringToDate("20040705091055990"); + Assert.AreEqual("2004-07-05 09:10:55:990", IsoFormat(d)); + + try + { + d = DateTools.StringToDate("97"); // no date + Assert.Fail(); + } // expected exception +#pragma warning disable 168 + catch (Exception e) +#pragma warning restore 168 + { + } + try + { + d = DateTools.StringToDate("200401011235009999"); // no date + Assert.Fail(); + } // expected exception +#pragma warning disable 168 + catch (Exception e) +#pragma warning restore 168 + { + } + try + { + d = DateTools.StringToDate("aaaa"); // no date + Assert.Fail(); + } // expected exception +#pragma warning disable 168 + catch (Exception e) +#pragma warning restore 168 + { + } + } + + [Test] + public virtual void TestStringtoTime() + { + long time = DateTools.StringToTime("197001010000"); + + // we use default locale since LuceneTestCase randomizes it + //Calendar cal = new GregorianCalendar(TimeZone.GetTimeZone("GMT"), Locale.Default); + //cal.Clear(); + + DateTime cal = new GregorianCalendar().ToDateTime(1970, 1, 1, 0, 0, 0, 0); // hour, minute, second - year=1970, month=january, day=1 + //cal.set(DateTime.MILLISECOND, 0); + Assert.AreEqual(cal.Ticks, time); + + cal = new GregorianCalendar().ToDateTime(1980, 2, 2, 11, 5, 0, 0); // hour, minute, second - year=1980, month=february, day=2 + //cal.set(DateTime.MILLISECOND, 0); + time = DateTools.StringToTime("198002021105"); + Assert.AreEqual(cal.Ticks, time); + } + + [Test] + public virtual void TestDateAndTimetoString() + { + // we use default locale since LuceneTestCase randomizes it + //Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.Default); + DateTime cal = new GregorianCalendar().ToDateTime(2004, 2, 3, 22, 8, 56, 333); + + /*cal.clear(); + cal = new DateTime(2004, 1, 3, 22, 8, 56); // hour, minute, second - year=2004, month=february(!), day=3 + cal.set(DateTime.MILLISECOND, 333);*/ + + string dateString = DateTools.DateToString(cal, DateTools.Resolution.YEAR); + Assert.AreEqual("2004", dateString); + Assert.AreEqual("2004-01-01 00:00:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.MONTH); + Assert.AreEqual("200402", dateString); + Assert.AreEqual("2004-02-01 00:00:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.DAY); + Assert.AreEqual("20040203", dateString); + Assert.AreEqual("2004-02-03 00:00:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.HOUR); + Assert.AreEqual("2004020322", dateString); + Assert.AreEqual("2004-02-03 22:00:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.MINUTE); + Assert.AreEqual("200402032208", dateString); + Assert.AreEqual("2004-02-03 22:08:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.SECOND); + Assert.AreEqual("20040203220856", dateString); + Assert.AreEqual("2004-02-03 22:08:56:000", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("20040203220856333", dateString); + Assert.AreEqual("2004-02-03 22:08:56:333", IsoFormat(DateTools.StringToDate(dateString))); + + // date before 1970: + cal = new GregorianCalendar().ToDateTime(1961, 3, 5, 23, 9, 51, 444); // hour, minute, second - year=1961, month=march(!), day=5 + //cal.set(DateTime.MILLISECOND, 444); + dateString = DateTools.DateToString(cal, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("19610305230951444", dateString); + Assert.AreEqual("1961-03-05 23:09:51:444", IsoFormat(DateTools.StringToDate(dateString))); + + dateString = DateTools.DateToString(cal, DateTools.Resolution.HOUR); + Assert.AreEqual("1961030523", dateString); + Assert.AreEqual("1961-03-05 23:00:00:000", IsoFormat(DateTools.StringToDate(dateString))); + + // timeToString: + cal = new GregorianCalendar().ToDateTime(1970, 1, 1, 0, 0, 0, 0); // hour, minute, second - year=1970, month=january, day=1 + //cal.set(DateTime.MILLISECOND, 0); + dateString = DateTools.TimeToString(cal.Ticks / TimeSpan.TicksPerMillisecond, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("19700101000000000", dateString); + + cal = new GregorianCalendar().ToDateTime(1970, 1, 1, 1, 2, 3, 0); // hour, minute, second - year=1970, month=january, day=1 + //cal.set(DateTime.MILLISECOND, 0); + dateString = DateTools.TimeToString(cal.Ticks / TimeSpan.TicksPerMillisecond, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("19700101010203000", dateString); + } + + [Test] + public virtual void TestRound() + { + // we use default locale since LuceneTestCase randomizes it + //Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.Default); + //cal.clear(); + DateTime cal = new GregorianCalendar().ToDateTime(2004, 2, 3, 22, 8, 56, 333); // hour, minute, second - year=2004, month=february(!), day=3 + //cal.set(DateTime.MILLISECOND, 333); + DateTime date = cal; + Assert.AreEqual("2004-02-03 22:08:56:333", IsoFormat(date)); + + DateTime dateYear = DateTools.Round(date, DateTools.Resolution.YEAR); + Assert.AreEqual("2004-01-01 00:00:00:000", IsoFormat(dateYear)); + + DateTime dateMonth = DateTools.Round(date, DateTools.Resolution.MONTH); + Assert.AreEqual("2004-02-01 00:00:00:000", IsoFormat(dateMonth)); + + DateTime dateDay = DateTools.Round(date, DateTools.Resolution.DAY); + Assert.AreEqual("2004-02-03 00:00:00:000", IsoFormat(dateDay)); + + DateTime dateHour = DateTools.Round(date, DateTools.Resolution.HOUR); + Assert.AreEqual("2004-02-03 22:00:00:000", IsoFormat(dateHour)); + + DateTime dateMinute = DateTools.Round(date, DateTools.Resolution.MINUTE); + Assert.AreEqual("2004-02-03 22:08:00:000", IsoFormat(dateMinute)); + + DateTime dateSecond = DateTools.Round(date, DateTools.Resolution.SECOND); + Assert.AreEqual("2004-02-03 22:08:56:000", IsoFormat(dateSecond)); + + DateTime dateMillisecond = DateTools.Round(date, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("2004-02-03 22:08:56:333", IsoFormat(dateMillisecond)); + + // long parameter: + long dateYearLong = DateTools.Round(date.Ticks / TimeSpan.TicksPerMillisecond, DateTools.Resolution.YEAR); + Assert.AreEqual("2004-01-01 00:00:00:000", IsoFormat(new DateTime(dateYearLong))); + + long dateMillisecondLong = DateTools.Round(date.Ticks / TimeSpan.TicksPerMillisecond, DateTools.Resolution.MILLISECOND); + Assert.AreEqual("2004-02-03 22:08:56:333", IsoFormat(new DateTime(dateMillisecondLong))); + } + + private string IsoFormat(DateTime date) + { + /*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS", Locale.ROOT); + sdf.TimeZone = TimeZone.getTimeZone("GMT"); + return sdf.Format(date);*/ + return date.ToString("yyyy-MM-dd HH:mm:ss:fff", System.Globalization.CultureInfo.InvariantCulture); + } + + [Test] + public virtual void TestDateToolsUTC() + { + /*// Sun, 30 Oct 2005 00:00:00 +0000 -- the last second of 2005's DST in Europe/London + long time = 1130630400; + try + { + TimeZone.Default = TimeZone.getTimeZone("Europe/London"); // "GMT" + string d1 = DateTools.DateToString(new DateTime(time * 1000), DateTools.Resolution.MINUTE); + string d2 = DateTools.DateToString(new DateTime((time+3600) * 1000), DateTools.Resolution.MINUTE); + Assert.IsFalse(d1.Equals(d2), "different times"); + Assert.AreEqual(DateTools.StringToTime(d1), time * 1000, "midnight"); + Assert.AreEqual(DateTools.StringToTime(d2), (time+3600) * 1000, "later"); + } + finally + { + TimeZone.Default = null; + }*/ + + // Sun, 30 Oct 2005 00:00:00 +0000 -- the last second of 2005's DST in Europe/London + //long time = 1130630400; + DateTime time1 = new DateTime(2005, 10, 30); + DateTime time2 = time1.AddHours(1); + try + { + //TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); // {{Aroush-2.0}} need porting 'java.util.TimeZone.getTimeZone' + System.DateTime tempAux = time1; + System.String d1 = DateTools.DateToString(tempAux, DateTools.Resolution.MINUTE); + System.DateTime tempAux2 = time2; + System.String d2 = DateTools.DateToString(tempAux2, DateTools.Resolution.MINUTE); + Assert.IsFalse(d1.Equals(d2), "different times"); + Assert.AreEqual(DateTools.StringToTime(d1), time1.Ticks, "midnight"); + Assert.AreEqual(DateTools.StringToTime(d2), time2.Ticks, "later"); + } + finally + { + //TimeZone.SetDefault(null); // {{Aroush-2.0}} need porting 'java.util.TimeZone.setDefault' + } + } + } +} \ No newline at end of file
