lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [48/72] [abbrv] [partial] lucenenet git commit: Lucene.Net.Tests: Removed \core directory and put its contents in root directory
Date Sun, 26 Feb 2017 23:37:36 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
new file mode 100644
index 0000000..e78db47
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
@@ -0,0 +1,145 @@
+using Lucene.Net.Attributes;
+using NUnit.Framework;
+
+namespace Lucene.Net.Codecs.Lucene3x
+{
+    /*
+     * 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 BaseStoredFieldsFormatTestCase = Lucene.Net.Index.BaseStoredFieldsFormatTestCase;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+
+    [TestFixture]
+    public class TestLucene3xStoredFieldsFormat : BaseStoredFieldsFormatTestCase
+    {
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.IsTrue(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "This should have been set up in the test fixture");
+                return new PreFlexRWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+        [Test]
+        public override void TestWriteReadMerge()
+        {
+            AssumeFalse("impersonation isnt good enough", true);
+            // this test tries to switch up between the codec and another codec.
+            // for 3.x: we currently cannot take an index with existing 4.x segments
+            // and merge into newly formed 3.x segments.
+        }
+
+
+
+        #region BaseStoredFieldsFormatTestCase
+        // 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 TestRandomStoredFields()
+        {
+            base.TestRandomStoredFields();
+        }
+
+        [Test]
+        // LUCENE-1727: make sure doc fields are stored in order
+        public override void TestStoredFieldsOrder()
+        {
+            base.TestStoredFieldsOrder();
+        }
+
+        [Test]
+        // LUCENE-1219
+        public override void TestBinaryFieldOffsetLength()
+        {
+            base.TestBinaryFieldOffsetLength();
+        }
+
+        [Test]
+        public override void TestNumericField()
+        {
+            base.TestNumericField();
+        }
+
+        [Test]
+        public override void TestIndexedBit()
+        {
+            base.TestIndexedBit();
+        }
+
+        [Test]
+        public override void TestReadSkip()
+        {
+            base.TestReadSkip();
+        }
+
+        [Test]
+        public override void TestEmptyDocs()
+        {
+            base.TestEmptyDocs();
+        }
+
+        [Test]
+        public override void TestConcurrentReads()
+        {
+            base.TestConcurrentReads();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(120000)]
+#endif
+        [Test, HasTimeout]
+        public override void TestBigDocuments()
+        {
+            base.TestBigDocuments();
+        }
+
+        [Test]
+        public override void TestBulkMergeWithDeletes()
+        {
+            base.TestBulkMergeWithDeletes();
+        }
+
+        #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/Lucene3x/TestLucene3xTermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
new file mode 100644
index 0000000..cbd59ed
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
@@ -0,0 +1,122 @@
+using NUnit.Framework;
+
+namespace Lucene.Net.Codecs.Lucene3x
+{
+    using System.Collections.Generic;
+    using Attributes;
+
+    /*
+         * 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 BaseTermVectorsFormatTestCase = Lucene.Net.Index.BaseTermVectorsFormatTestCase;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+
+    public class TestLucene3xTermVectorsFormat : BaseTermVectorsFormatTestCase
+    {
+        [SetUp]
+        public override void SetUp()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true;
+            base.SetUp();
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.IsTrue(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "This should have been set up in the test fixture");
+                return new PreFlexRWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+        protected override IEnumerable<Options> ValidOptions()
+        {
+            return ValidOptions(Options.NONE, Options.POSITIONS_AND_OFFSETS);
+        }
+
+
+        #region BaseTermVectorsFormatTestCase
+        // 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]
+        // only one doc with vectors
+        public override void TestRareVectors()
+        {
+            base.TestRareVectors();
+        }
+
+        [Test]
+        public override void TestHighFreqs()
+        {
+            base.TestHighFreqs();
+        }
+
+        [Test]
+        public override void TestLotsOfFields()
+        {
+            base.TestLotsOfFields();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(300000)]
+#endif
+        [Test, HasTimeout]
+        // different options for the same field
+        public override void TestMixedOptions()
+        {
+            base.TestMixedOptions();
+        }
+
+        [Test]
+        public override void TestRandom()
+        {
+            base.TestRandom();
+        }
+
+        [Test]
+        public override void TestMerge()
+        {
+            base.TestMerge();
+        }
+
+        [Test]
+        // run random tests from different threads to make sure the per-thread clones
+        // don't share mutable data
+        public override void TestClone()
+        {
+            base.TestClone();
+        }
+
+        #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/Lucene3x/TestSurrogates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
new file mode 100644
index 0000000..d4b1b63
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
@@ -0,0 +1,424 @@
+using System;
+using System.Collections.Generic;
+using Lucene.Net.Documents;
+
+namespace Lucene.Net.Codecs.Lucene3x
+{
+    using Attributes;
+    using Lucene.Net.Analysis;
+    using Lucene.Net.Index;
+
+    /*
+         * 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 Lucene.Net.Store;
+    using Lucene.Net.Util;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class TestSurrogates : LuceneTestCase
+    {
+        /// <summary>
+        /// we will manually instantiate preflex-rw here
+        /// 
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true;
+        }
+
+        private static string MakeDifficultRandomUnicodeString(Random r)
+        {
+            int end = r.Next(20);
+            if (end == 0)
+            {
+                // allow 0 length
+                return "";
+            }
+            char[] buffer = new char[end];
+            for (int i = 0; i < end; i++)
+            {
+                int t = r.Next(5);
+
+                if (0 == t && i < end - 1)
+                {
+                    // hi
+                    buffer[i++] = (char)(0xd800 + r.Next(2));
+                    // lo
+                    buffer[i] = (char)(0xdc00 + r.Next(2));
+                }
+                else if (t <= 3)
+                {
+                    buffer[i] = (char)('a' + r.Next(2));
+                }
+                else if (4 == t)
+                {
+                    buffer[i] = (char)(0xe000 + r.Next(2));
+                }
+            }
+
+            return new string(buffer, 0, end);
+        }
+
+        private static string ToHexString(Term t)
+        {
+            return t.Field + ":" + UnicodeUtil.ToHexString(t.Text());
+        }
+
+        private string GetRandomString(Random r)
+        {
+            string s;
+            if (r.Next(5) == 1)
+            {
+                if (r.Next(3) == 1)
+                {
+                    s = MakeDifficultRandomUnicodeString(r);
+                }
+                else
+                {
+                    s = TestUtil.RandomUnicodeString(r);
+                }
+            }
+            else
+            {
+                s = TestUtil.RandomRealisticUnicodeString(r);
+            }
+            return s;
+        }
+
+        private sealed class SortTermAsUTF16Comparer : IComparer<Term>
+        {
+#pragma warning disable 612, 618
+            private static readonly IComparer<BytesRef> LegacyComparer = BytesRef.UTF8SortedAsUTF16Comparer;
+#pragma warning restore 612, 618
+
+            public int Compare(Term term1, Term term2)
+            {
+                if (term1.Field.Equals(term2.Field))
+                {
+                    return LegacyComparer.Compare(term1.Bytes, term2.Bytes);
+                }
+                else
+                {
+                    return System.String.Compare(term1.Field, term2.Field, System.StringComparison.Ordinal);
+                }
+            }
+        }
+
+        private static readonly SortTermAsUTF16Comparer TermAsUTF16Comparer = new SortTermAsUTF16Comparer();
+
+        // single straight enum
+        private void DoTestStraightEnum(IList<Term> fieldTerms, IndexReader reader, int uniqueTermCount)
+        {
+            if (VERBOSE)
+            {
+                Console.WriteLine("\nTEST: top now enum reader=" + reader);
+            }
+            Fields fields = MultiFields.GetFields(reader);
+            {
+                // Test straight enum:
+                int termCount = 0;
+                foreach (string field in fields)
+                {
+                    Terms terms = fields.GetTerms(field);
+                    Assert.IsNotNull(terms);
+                    TermsEnum termsEnum = terms.GetIterator(null);
+                    BytesRef text;
+                    BytesRef lastText = null;
+                    while ((text = termsEnum.Next()) != null)
+                    {
+                        Term exp = fieldTerms[termCount];
+                        if (VERBOSE)
+                        {
+                            Console.WriteLine("  got term=" + field + ":" + UnicodeUtil.ToHexString(text.Utf8ToString()));
+                            Console.WriteLine("       exp=" + exp.Field + ":" + UnicodeUtil.ToHexString(exp.Text()));
+                            Console.WriteLine();
+                        }
+                        if (lastText == null)
+                        {
+                            lastText = BytesRef.DeepCopyOf(text);
+                        }
+                        else
+                        {
+                            Assert.IsTrue(lastText.CompareTo(text) < 0);
+                            lastText.CopyBytes(text);
+                        }
+                        Assert.AreEqual(exp.Field, field);
+                        Assert.AreEqual(exp.Bytes, text);
+                        termCount++;
+                    }
+                    if (VERBOSE)
+                    {
+                        Console.WriteLine("  no more terms for field=" + field);
+                    }
+                }
+                Assert.AreEqual(uniqueTermCount, termCount);
+            }
+        }
+
+        // randomly seeks to term that we know exists, then next's
+        // from there
+        private void DoTestSeekExists(Random r, IList<Term> fieldTerms, IndexReader reader)
+        {
+            IDictionary<string, TermsEnum> tes = new Dictionary<string, TermsEnum>();
+
+            // Test random seek to existing term, then enum:
+            if (VERBOSE)
+            {
+                Console.WriteLine("\nTEST: top now seek");
+            }
+
+            int num = AtLeast(100);
+            for (int iter = 0; iter < num; iter++)
+            {
+                // pick random field+term
+                int spot = r.Next(fieldTerms.Count);
+                Term term = fieldTerms[spot];
+                string field = term.Field;
+
+                if (VERBOSE)
+                {
+                    Console.WriteLine("TEST: exist seek field=" + field + " term=" + UnicodeUtil.ToHexString(term.Text()));
+                }
+
+                // seek to it
+                TermsEnum te;
+                if (!tes.TryGetValue(field, out te))
+                {
+                    te = MultiFields.GetTerms(reader, field).GetIterator(null);
+                    tes[field] = te;
+                }
+
+                if (VERBOSE)
+                {
+                    Console.WriteLine("  done get enum");
+                }
+
+                // seek should find the term
+                Assert.AreEqual(TermsEnum.SeekStatus.FOUND, te.SeekCeil(term.Bytes));
+
+                // now .next() this many times:
+                int ct = TestUtil.NextInt(r, 5, 100);
+                for (int i = 0; i < ct; i++)
+                {
+                    if (VERBOSE)
+                    {
+                        Console.WriteLine("TEST: now next()");
+                    }
+                    if (1 + spot + i >= fieldTerms.Count)
+                    {
+                        break;
+                    }
+                    term = fieldTerms[1 + spot + i];
+                    if (!term.Field.Equals(field))
+                    {
+                        Assert.IsNull(te.Next());
+                        break;
+                    }
+                    else
+                    {
+                        BytesRef t = te.Next();
+
+                        if (VERBOSE)
+                        {
+                            Console.WriteLine("  got term=" + (t == null ? null : UnicodeUtil.ToHexString(t.Utf8ToString())));
+                            Console.WriteLine("       exp=" + UnicodeUtil.ToHexString(term.Text().ToString()));
+                        }
+
+                        Assert.AreEqual(term.Bytes, t);
+                    }
+                }
+            }
+        }
+
+        private void DoTestSeekDoesNotExist(Random r, int numField, IList<Term> fieldTerms, Term[] fieldTermsArray, IndexReader reader)
+        {
+            IDictionary<string, TermsEnum> tes = new Dictionary<string, TermsEnum>();
+
+            if (VERBOSE)
+            {
+                Console.WriteLine("TEST: top random seeks");
+            }
+
+            {
+                int num = AtLeast(100);
+                for (int iter = 0; iter < num; iter++)
+                {
+                    // seek to random spot
+                    string field = StringHelper.Intern("f" + r.Next(numField));
+                    Term tx = new Term(field, GetRandomString(r));
+
+                    int spot = Array.BinarySearch(fieldTermsArray, tx);
+
+                    if (spot < 0)
+                    {
+                        if (VERBOSE)
+                        {
+                            Console.WriteLine("TEST: non-exist seek to " + field + ":" + UnicodeUtil.ToHexString(tx.Text()));
+                        }
+
+                        // term does not exist:
+                        TermsEnum te;
+                        if (!tes.TryGetValue(field, out te))
+                        {
+                            te = MultiFields.GetTerms(reader, field).GetIterator(null);
+                            tes[field] = te;
+                        }
+
+                        if (VERBOSE)
+                        {
+                            Console.WriteLine("  got enum");
+                        }
+
+                        spot = -spot - 1;
+
+                        if (spot == fieldTerms.Count || !fieldTerms[spot].Field.Equals(field))
+                        {
+                            Assert.AreEqual(TermsEnum.SeekStatus.END, te.SeekCeil(tx.Bytes));
+                        }
+                        else
+                        {
+                            Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, te.SeekCeil(tx.Bytes));
+
+                            if (VERBOSE)
+                            {
+                                Console.WriteLine("  got term=" + UnicodeUtil.ToHexString(te.Term.Utf8ToString()));
+                                Console.WriteLine("  exp term=" + UnicodeUtil.ToHexString(fieldTerms[spot].Text()));
+                            }
+
+                            Assert.AreEqual(fieldTerms[spot].Bytes, te.Term);
+
+                            // now .next() this many times:
+                            int ct = TestUtil.NextInt(r, 5, 100);
+                            for (int i = 0; i < ct; i++)
+                            {
+                                if (VERBOSE)
+                                {
+                                    Console.WriteLine("TEST: now next()");
+                                }
+                                if (1 + spot + i >= fieldTerms.Count)
+                                {
+                                    break;
+                                }
+                                Term term = fieldTerms[1 + spot + i];
+                                if (!term.Field.Equals(field))
+                                {
+                                    Assert.IsNull(te.Next());
+                                    break;
+                                }
+                                else
+                                {
+                                    BytesRef t = te.Next();
+
+                                    if (VERBOSE)
+                                    {
+                                        Console.WriteLine("  got term=" + (t == null ? null : UnicodeUtil.ToHexString(t.Utf8ToString())));
+                                        Console.WriteLine("       exp=" + UnicodeUtil.ToHexString(term.Text().ToString()));
+                                    }
+
+                                    Assert.AreEqual(term.Bytes, t);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(300000)]
+#endif
+        [Test, HasTimeout]
+        public virtual void TestSurrogatesOrder()
+        {
+            Directory dir = NewDirectory();
+            RandomIndexWriter w = new RandomIndexWriter(Random(), dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()))
+                .SetCodec(new PreFlexRWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE)));
+
+            int numField = TestUtil.NextInt(Random(), 2, 5);
+
+            int uniqueTermCount = 0;
+
+            int tc = 0;
+
+            var fieldTerms = new List<Term>();
+
+            for (int f = 0; f < numField; f++)
+            {
+                string field = "f" + f;
+                int numTerms = AtLeast(200);
+
+                ISet<string> uniqueTerms = new HashSet<string>();
+
+                for (int i = 0; i < numTerms; i++)
+                {
+                    string term = GetRandomString(Random()) + "_ " + (tc++);
+                    uniqueTerms.Add(term);
+                    fieldTerms.Add(new Term(field, term));
+                    Documents.Document doc = new Documents.Document();
+                    doc.Add(NewStringField(field, term, Field.Store.NO));
+                    w.AddDocument(doc);
+                }
+                uniqueTermCount += uniqueTerms.Count;
+            }
+
+            IndexReader reader = w.Reader;
+
+            if (VERBOSE)
+            {
+                fieldTerms.Sort(TermAsUTF16Comparer);
+
+                Console.WriteLine("\nTEST: UTF16 order");
+                foreach (Term t in fieldTerms)
+                {
+                    Console.WriteLine("  " + ToHexString(t));
+                }
+            }
+
+            // sorts in code point order:
+            fieldTerms.Sort();
+
+            if (VERBOSE)
+            {
+                Console.WriteLine("\nTEST: codepoint order");
+                foreach (Term t in fieldTerms)
+                {
+                    Console.WriteLine("  " + ToHexString(t));
+                }
+            }
+
+            Term[] fieldTermsArray = fieldTerms.ToArray();
+
+            //SegmentInfo si = makePreFlexSegment(r, "_0", dir, fieldInfos, codec, fieldTerms);
+
+            //FieldsProducer fields = codec.fieldsProducer(new SegmentReadState(dir, si, fieldInfos, 1024, 1));
+            //Assert.IsNotNull(fields);
+
+            DoTestStraightEnum(fieldTerms, reader, uniqueTermCount);
+            DoTestSeekExists(Random(), fieldTerms, reader);
+            DoTestSeekDoesNotExist(Random(), numField, fieldTerms, fieldTermsArray, reader);
+
+            reader.Dispose();
+            w.Dispose();
+            dir.Dispose();
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestTermInfosReaderIndex.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
new file mode 100644
index 0000000..2d9dd05
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestTermInfosReaderIndex.cs
@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using Lucene.Net.Documents;
+
+namespace Lucene.Net.Codecs.Lucene3x
+{
+    using Lucene.Net.Support;
+    using NUnit.Framework;
+    using Directory = Lucene.Net.Store.Directory;
+    using DirectoryReader = Lucene.Net.Index.DirectoryReader;
+    using Document = Documents.Document;
+    using Field = Field;
+    using FieldInfos = Lucene.Net.Index.FieldInfos;
+    using Fields = Lucene.Net.Index.Fields;
+    using IndexFileNames = Lucene.Net.Index.IndexFileNames;
+    using IndexInput = Lucene.Net.Store.IndexInput;
+    using IndexReader = Lucene.Net.Index.IndexReader;
+    using IndexSearcher = Lucene.Net.Search.IndexSearcher;
+    using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig;
+    using IOContext = Lucene.Net.Store.IOContext;
+    using LogMergePolicy = Lucene.Net.Index.LogMergePolicy;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+
+    /*
+         * 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 MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
+    using MockTokenizer = Lucene.Net.Analysis.MockTokenizer;
+    using MultiFields = Lucene.Net.Index.MultiFields;
+    using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
+    using SegmentReader = Lucene.Net.Index.SegmentReader;
+    using Term = Lucene.Net.Index.Term;
+    using TermQuery = Lucene.Net.Search.TermQuery;
+    using Terms = Lucene.Net.Index.Terms;
+    using TermsEnum = Lucene.Net.Index.TermsEnum;
+    using TestUtil = Lucene.Net.Util.TestUtil;
+    using TopDocs = Lucene.Net.Search.TopDocs;
+
+#pragma warning disable 612, 618
+    [TestFixture]
+    public class TestTermInfosReaderIndex : LuceneTestCase
+    {
+        private static int NUMBER_OF_DOCUMENTS;
+        private static int NUMBER_OF_FIELDS;
+        private static TermInfosReaderIndex Index;
+        private static Directory Directory;
+        private static SegmentTermEnum TermEnum;
+        private static int IndexDivisor;
+        private static int TermIndexInterval;
+        private static IndexReader Reader;
+        private static IList<Term> SampleTerms;
+
+        /// <summary>
+        /// we will manually instantiate preflex-rw here
+        /// 
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            // NOTE: turn off compound file, this test will open some index files directly.
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true;
+            IndexWriterConfig config = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random(), MockTokenizer.KEYWORD, false)).SetUseCompoundFile(false);
+
+            TermIndexInterval = config.TermIndexInterval;
+            IndexDivisor = TestUtil.NextInt(Random(), 1, 10);
+            NUMBER_OF_DOCUMENTS = AtLeast(100);
+            NUMBER_OF_FIELDS = AtLeast(Math.Max(10, 3 * TermIndexInterval * IndexDivisor / NUMBER_OF_DOCUMENTS));
+
+            Directory = NewDirectory();
+
+            config.SetCodec(new PreFlexRWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE));
+            LogMergePolicy mp = NewLogMergePolicy();
+            // NOTE: turn off compound file, this test will open some index files directly.
+            mp.NoCFSRatio = 0.0;
+            config.SetMergePolicy(mp);
+
+            Populate(Directory, config);
+
+            DirectoryReader r0 = IndexReader.Open(Directory);
+            SegmentReader r = LuceneTestCase.GetOnlySegmentReader(r0);
+            string segment = r.SegmentName;
+            r.Dispose();
+
+            FieldInfosReader infosReader = (new PreFlexRWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE)).FieldInfosFormat.FieldInfosReader;
+            FieldInfos fieldInfos = infosReader.Read(Directory, segment, "", IOContext.READ_ONCE);
+            string segmentFileName = IndexFileNames.SegmentFileName(segment, "", Lucene3xPostingsFormat.TERMS_INDEX_EXTENSION);
+            long tiiFileLength = Directory.FileLength(segmentFileName);
+            IndexInput input = Directory.OpenInput(segmentFileName, NewIOContext(Random()));
+            TermEnum = new SegmentTermEnum(Directory.OpenInput(IndexFileNames.SegmentFileName(segment, "", Lucene3xPostingsFormat.TERMS_EXTENSION), NewIOContext(Random())), fieldInfos, false);
+            int totalIndexInterval = TermEnum.indexInterval * IndexDivisor;
+
+            SegmentTermEnum indexEnum = new SegmentTermEnum(input, fieldInfos, true);
+            Index = new TermInfosReaderIndex(indexEnum, IndexDivisor, tiiFileLength, totalIndexInterval);
+            indexEnum.Dispose();
+            input.Dispose();
+
+            Reader = IndexReader.Open(Directory);
+            SampleTerms = Sample(Random(), Reader, 1000);
+        }
+
+        [OneTimeTearDown]
+        public static void AfterClass()
+        {
+            TermEnum.Dispose();
+            Reader.Dispose();
+            Directory.Dispose();
+            TermEnum = null;
+            Reader = null;
+            Directory = null;
+            Index = null;
+            SampleTerms = null;
+        }
+
+        [Test]
+        public virtual void TestSeekEnum()
+        {
+            int indexPosition = 3;
+            SegmentTermEnum clone = (SegmentTermEnum)TermEnum.Clone();
+            Term term = FindTermThatWouldBeAtIndex(clone, indexPosition);
+            SegmentTermEnum enumerator = clone;
+            Index.SeekEnum(enumerator, indexPosition);
+            Assert.AreEqual(term, enumerator.Term());
+            clone.Dispose();
+        }
+
+        [Test]
+        public virtual void TestCompareTo()
+        {
+            Term term = new Term("field" + Random().Next(NUMBER_OF_FIELDS), Text);
+            for (int i = 0; i < Index.Length; i++)
+            {
+                Term t = Index.GetTerm(i);
+                int compareTo = term.CompareTo(t);
+                Assert.AreEqual(compareTo, Index.CompareTo(term, i));
+            }
+        }
+
+        [Test]
+        public virtual void TestRandomSearchPerformance()
+        {
+            IndexSearcher searcher = new IndexSearcher(Reader);
+            foreach (Term t in SampleTerms)
+            {
+                TermQuery query = new TermQuery(t);
+                TopDocs topDocs = searcher.Search(query, 10);
+                Assert.IsTrue(topDocs.TotalHits > 0);
+            }
+        }
+
+        private static IList<Term> Sample(Random random, IndexReader reader, int size)
+        {
+            IList<Term> sample = new List<Term>();
+            Fields fields = MultiFields.GetFields(reader);
+            foreach (string field in fields)
+            {
+                Terms terms = fields.GetTerms(field);
+                Assert.IsNotNull(terms);
+                TermsEnum termsEnum = terms.GetIterator(null);
+                while (termsEnum.Next() != null)
+                {
+                    if (sample.Count >= size)
+                    {
+                        int pos = random.Next(size);
+                        sample[pos] = new Term(field, termsEnum.Term);
+                    }
+                    else
+                    {
+                        sample.Add(new Term(field, termsEnum.Term));
+                    }
+                }
+            }
+            Collections.Shuffle(sample);
+            return sample;
+        }
+
+        private Term FindTermThatWouldBeAtIndex(SegmentTermEnum termEnum, int index)
+        {
+            int termPosition = index * TermIndexInterval * IndexDivisor;
+            for (int i = 0; i < termPosition; i++)
+            {
+                // TODO: this test just uses random terms, so this is always possible
+                AssumeTrue("ran out of terms", termEnum.Next());
+            }
+            Term term = termEnum.Term();
+            // An indexed term is only written when the term after
+            // it exists, so, if the number of terms is 0 mod
+            // termIndexInterval, the last index term will not be
+            // written; so we require a term after this term
+            // as well:
+            AssumeTrue("ran out of terms", termEnum.Next());
+            return term;
+        }
+
+        private void Populate(Directory directory, IndexWriterConfig config)
+        {
+            RandomIndexWriter writer = new RandomIndexWriter(Random(), directory, config);
+            for (int i = 0; i < NUMBER_OF_DOCUMENTS; i++)
+            {
+                Document document = new Document();
+                for (int f = 0; f < NUMBER_OF_FIELDS; f++)
+                {
+                    document.Add(NewStringField("field" + f, Text, Field.Store.NO));
+                }
+                writer.AddDocument(document);
+            }
+            writer.ForceMerge(1);
+            writer.Dispose();
+        }
+
+        private static string Text
+        {
+            get
+            {
+                return Convert.ToString(Random().Next());
+            }
+        }
+    }
+#pragma warning restore 612, 618
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene40/TestBitVector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestBitVector.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestBitVector.cs
new file mode 100644
index 0000000..3103129
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestBitVector.cs
@@ -0,0 +1,325 @@
+namespace Lucene.Net.Codecs.Lucene40
+{
+    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 Directory = Lucene.Net.Store.Directory;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+    using MockDirectoryWrapper = Lucene.Net.Store.MockDirectoryWrapper;
+    using RAMDirectory = Lucene.Net.Store.RAMDirectory;
+    using TestUtil = Lucene.Net.Util.TestUtil;
+
+    /// <summary>
+    /// <code>TestBitVector</code> tests the <code>BitVector</code>, obviously.
+    /// </summary>
+    [TestFixture]
+    public class TestBitVector : LuceneTestCase
+    {
+        /// <summary>
+        /// Test the default constructor on BitVectors of various sizes.
+        /// </summary>
+        [Test]
+        public virtual void TestConstructSize()
+        {
+            DoTestConstructOfSize(8);
+            DoTestConstructOfSize(20);
+            DoTestConstructOfSize(100);
+            DoTestConstructOfSize(1000);
+        }
+
+        private void DoTestConstructOfSize(int n)
+        {
+            BitVector bv = new BitVector(n);
+            Assert.AreEqual(n, bv.Length); // LUCENENET NOTE: Length is the equivalent of size()
+        }
+
+        /// <summary>
+        /// Test the get() and set() methods on BitVectors of various sizes.
+        /// </summary>
+        [Test]
+        public virtual void TestGetSet()
+        {
+            DoTestGetSetVectorOfSize(8);
+            DoTestGetSetVectorOfSize(20);
+            DoTestGetSetVectorOfSize(100);
+            DoTestGetSetVectorOfSize(1000);
+        }
+
+        private void DoTestGetSetVectorOfSize(int n)
+        {
+            BitVector bv = new BitVector(n);
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                // ensure a set bit can be git'
+                Assert.IsFalse(bv.Get(i));
+                bv.Set(i);
+                Assert.IsTrue(bv.Get(i));
+            }
+        }
+
+        /// <summary>
+        /// Test the clear() method on BitVectors of various sizes.
+        /// </summary>
+        [Test]
+        public virtual void TestClear()
+        {
+            DoTestClearVectorOfSize(8);
+            DoTestClearVectorOfSize(20);
+            DoTestClearVectorOfSize(100);
+            DoTestClearVectorOfSize(1000);
+        }
+
+        private void DoTestClearVectorOfSize(int n)
+        {
+            BitVector bv = new BitVector(n);
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                // ensure a set bit is cleared
+                Assert.IsFalse(bv.Get(i));
+                bv.Set(i);
+                Assert.IsTrue(bv.Get(i));
+                bv.Clear(i);
+                Assert.IsFalse(bv.Get(i));
+            }
+        }
+
+        /// <summary>
+        /// Test the count() method on BitVectors of various sizes.
+        /// </summary>
+        [Test]
+        public virtual void TestCount()
+        {
+            DoTestCountVectorOfSize(8);
+            DoTestCountVectorOfSize(20);
+            DoTestCountVectorOfSize(100);
+            DoTestCountVectorOfSize(1000);
+        }
+
+        private void DoTestCountVectorOfSize(int n)
+        {
+            BitVector bv = new BitVector(n);
+            // test count when incrementally setting bits
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                Assert.IsFalse(bv.Get(i));
+                Assert.AreEqual(i, bv.Count());
+                bv.Set(i);
+                Assert.IsTrue(bv.Get(i));
+                Assert.AreEqual(i + 1, bv.Count());
+            }
+
+            bv = new BitVector(n);
+            // test count when setting then clearing bits
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                Assert.IsFalse(bv.Get(i));
+                Assert.AreEqual(0, bv.Count());
+                bv.Set(i);
+                Assert.IsTrue(bv.Get(i));
+                Assert.AreEqual(1, bv.Count());
+                bv.Clear(i);
+                Assert.IsFalse(bv.Get(i));
+                Assert.AreEqual(0, bv.Count());
+            }
+        }
+
+        /// <summary>
+        /// Test writing and construction to/from Directory.
+        /// </summary>
+        [Test]
+        public virtual void TestWriteRead()
+        {
+            DoTestWriteRead(8);
+            DoTestWriteRead(20);
+            DoTestWriteRead(100);
+            DoTestWriteRead(1000);
+        }
+
+        private void DoTestWriteRead(int n)
+        {
+            MockDirectoryWrapper d = new MockDirectoryWrapper(Random(), new RAMDirectory());
+            d.PreventDoubleWrite = false;
+            BitVector bv = new BitVector(n);
+            // test count when incrementally setting bits
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                Assert.IsFalse(bv.Get(i));
+                Assert.AreEqual(i, bv.Count());
+                bv.Set(i);
+                Assert.IsTrue(bv.Get(i));
+                Assert.AreEqual(i + 1, bv.Count());
+                bv.Write(d, "TESTBV", NewIOContext(Random()));
+                BitVector compare = new BitVector(d, "TESTBV", NewIOContext(Random()));
+                // compare bit vectors with bits set incrementally
+                Assert.IsTrue(DoCompare(bv, compare));
+            }
+        }
+
+        /// <summary>
+        /// Test r/w when size/count cause switching between bit-set and d-gaps file formats.
+        /// </summary>
+        [Test]
+        public virtual void TestDgaps()
+        {
+            DoTestDgaps(1, 0, 1);
+            DoTestDgaps(10, 0, 1);
+            DoTestDgaps(100, 0, 1);
+            DoTestDgaps(1000, 4, 7);
+            DoTestDgaps(10000, 40, 43);
+            DoTestDgaps(100000, 415, 418);
+            DoTestDgaps(1000000, 3123, 3126);
+            // now exercise skipping of fully populated byte in the bitset (they are omitted if bitset is sparse)
+            MockDirectoryWrapper d = new MockDirectoryWrapper(Random(), new RAMDirectory());
+            d.PreventDoubleWrite = false;
+            BitVector bv = new BitVector(10000);
+            bv.Set(0);
+            for (int i = 8; i < 16; i++)
+            {
+                bv.Set(i);
+            } // make sure we have once byte full of set bits
+            for (int i = 32; i < 40; i++)
+            {
+                bv.Set(i);
+            } // get a second byte full of set bits
+            // add some more bits here
+            for (int i = 40; i < 10000; i++)
+            {
+                if (Random().Next(1000) == 0)
+                {
+                    bv.Set(i);
+                }
+            }
+            bv.Write(d, "TESTBV", NewIOContext(Random()));
+            BitVector compare = new BitVector(d, "TESTBV", NewIOContext(Random()));
+            Assert.IsTrue(DoCompare(bv, compare));
+        }
+
+        private void DoTestDgaps(int size, int count1, int count2)
+        {
+            MockDirectoryWrapper d = new MockDirectoryWrapper(Random(), new RAMDirectory());
+            d.PreventDoubleWrite = false;
+            BitVector bv = new BitVector(size);
+            bv.InvertAll();
+            for (int i = 0; i < count1; i++)
+            {
+                bv.Clear(i);
+                Assert.AreEqual(i + 1, size - bv.Count());
+            }
+            bv.Write(d, "TESTBV", NewIOContext(Random()));
+            // gradually increase number of set bits
+            for (int i = count1; i < count2; i++)
+            {
+                BitVector bv2 = new BitVector(d, "TESTBV", NewIOContext(Random()));
+                Assert.IsTrue(DoCompare(bv, bv2));
+                bv = bv2;
+                bv.Clear(i);
+                Assert.AreEqual(i + 1, size - bv.Count());
+                bv.Write(d, "TESTBV", NewIOContext(Random()));
+            }
+            // now start decreasing number of set bits
+            for (int i = count2 - 1; i >= count1; i--)
+            {
+                BitVector bv2 = new BitVector(d, "TESTBV", NewIOContext(Random()));
+                Assert.IsTrue(DoCompare(bv, bv2));
+                bv = bv2;
+                bv.Set(i);
+                Assert.AreEqual(i, size - bv.Count());
+                bv.Write(d, "TESTBV", NewIOContext(Random()));
+            }
+        }
+
+        [Test]
+        public virtual void TestSparseWrite()
+        {
+            Directory d = NewDirectory();
+            const int numBits = 10240;
+            BitVector bv = new BitVector(numBits);
+            bv.InvertAll();
+            int numToClear = Random().Next(5);
+            for (int i = 0; i < numToClear; i++)
+            {
+                bv.Clear(Random().Next(numBits));
+            }
+            bv.Write(d, "test", NewIOContext(Random()));
+            long size = d.FileLength("test");
+            Assert.IsTrue(size < 100, "size=" + size);
+            d.Dispose();
+        }
+
+        [Test]
+        public virtual void TestClearedBitNearEnd()
+        {
+            Directory d = NewDirectory();
+            int numBits = TestUtil.NextInt(Random(), 7, 1000);
+            BitVector bv = new BitVector(numBits);
+            bv.InvertAll();
+            bv.Clear(numBits - TestUtil.NextInt(Random(), 1, 7));
+            bv.Write(d, "test", NewIOContext(Random()));
+            Assert.AreEqual(numBits - 1, bv.Count());
+            d.Dispose();
+        }
+
+        [Test]
+        public virtual void TestMostlySet()
+        {
+            Directory d = NewDirectory();
+            int numBits = TestUtil.NextInt(Random(), 30, 1000);
+            for (int numClear = 0; numClear < 20; numClear++)
+            {
+                BitVector bv = new BitVector(numBits);
+                bv.InvertAll();
+                int count = 0;
+                while (count < numClear)
+                {
+                    int bit = Random().Next(numBits);
+                    // Don't use getAndClear, so that count is recomputed
+                    if (bv.Get(bit))
+                    {
+                        bv.Clear(bit);
+                        count++;
+                        Assert.AreEqual(numBits - count, bv.Count());
+                    }
+                }
+            }
+
+            d.Dispose();
+        }
+
+        /// <summary>
+        /// Compare two BitVectors.
+        /// this should really be an equals method on the BitVector itself. </summary>
+        /// <param name="bv"> One bit vector </param>
+        /// <param name="compare"> The second to compare </param>
+        private bool DoCompare(BitVector bv, BitVector compare)
+        {
+            bool equal = true;
+            for (int i = 0; i < bv.Length; i++) // LUCENENET NOTE: Length is the equivalent of size()
+            {
+                // bits must be equal
+                if (bv.Get(i) != compare.Get(i))
+                {
+                    equal = false;
+                    break;
+                }
+            }
+            Assert.AreEqual(bv.Count(), compare.Count());
+            return equal;
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40DocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40DocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40DocValuesFormat.cs
new file mode 100644
index 0000000..d63a6b3
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40DocValuesFormat.cs
@@ -0,0 +1,555 @@
+namespace Lucene.Net.Codecs.Lucene40
+{
+    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 BaseDocValuesFormatTestCase = Lucene.Net.Index.BaseDocValuesFormatTestCase;
+
+    /// <summary>
+    /// Tests Lucene40DocValuesFormat
+    /// </summary>
+    public class TestLucene40DocValuesFormat : BaseDocValuesFormatTestCase
+    {
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.True(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "Expecting that this is true");
+                return new Lucene40RWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+        // LUCENE-4583: this codec should throw IAE on huge binary values:
+        protected internal override bool CodecAcceptsHugeBinaryValues(string field)
+        {
+            return false;
+        }
+
+
+        #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/Lucene40/TestLucene40PostingsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsFormat.cs
new file mode 100644
index 0000000..2d2b5f1
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsFormat.cs
@@ -0,0 +1,111 @@
+namespace Lucene.Net.Codecs.Lucene40
+{
+    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;
+
+    /// <summary>
+    /// Tests Lucene40PostingsFormat
+    /// </summary>
+    public class TestLucene40PostingsFormat : BasePostingsFormatTestCase
+    {
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.True(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "Expecting this to be set already before creating codec");
+                return new Lucene40RWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+
+        #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
+
+        #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/Lucene40/TestLucene40PostingsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsReader.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsReader.cs
new file mode 100644
index 0000000..aea5ce0
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40PostingsReader.cs
@@ -0,0 +1,166 @@
+using Lucene.Net.Documents;
+using Lucene.Net.Index;
+using Lucene.Net.Support;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Lucene.Net.Codecs.Lucene40
+{
+    using Lucene.Net.Randomized.Generators;
+    using NUnit.Framework;
+    using Directory = Lucene.Net.Store.Directory;
+    using Document = Documents.Document;
+    using Field = Field;
+    using FieldType = FieldType;
+    using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+
+    /*
+         * 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 MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
+    using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
+    using StringField = StringField;
+    using Term = Lucene.Net.Index.Term;
+    using TestUtil = Lucene.Net.Util.TestUtil;
+    using TextField = TextField;
+
+    [TestFixture]
+    public class TestLucene40PostingsReader : LuceneTestCase
+    {
+        internal static readonly string[] Terms = new string[100];
+
+        static TestLucene40PostingsReader()
+        {
+            for (int i = 0; i < Terms.Length; i++)
+            {
+                Terms[i] = Convert.ToString(i + 1);
+            }
+        }
+
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        /// <summary>
+        /// tests terms with different probabilities of being in the document.
+        ///  depends heavily on term vectors cross-check at checkIndex
+        /// </summary>
+        [Test]
+        public virtual void TestPostings()
+        {
+            Directory dir = NewFSDirectory(CreateTempDir("postings"));
+            IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
+            iwc.SetCodec(Codec.ForName("Lucene40"));
+            RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, iwc);
+
+            Document doc = new Document();
+
+            // id field
+            FieldType idType = new FieldType(StringField.TYPE_NOT_STORED);
+            idType.StoreTermVectors = true;
+            Field idField = new Field("id", "", idType);
+            doc.Add(idField);
+
+            // title field: short text field
+            FieldType titleType = new FieldType(TextField.TYPE_NOT_STORED);
+            titleType.StoreTermVectors = true;
+            titleType.StoreTermVectorPositions = true;
+            titleType.StoreTermVectorOffsets = true;
+            titleType.IndexOptions = IndexOptions();
+            Field titleField = new Field("title", "", titleType);
+            doc.Add(titleField);
+
+            // body field: long text field
+            FieldType bodyType = new FieldType(TextField.TYPE_NOT_STORED);
+            bodyType.StoreTermVectors = true;
+            bodyType.StoreTermVectorPositions = true;
+            bodyType.StoreTermVectorOffsets = true;
+            bodyType.IndexOptions = IndexOptions();
+            Field bodyField = new Field("body", "", bodyType);
+            doc.Add(bodyField);
+
+            int numDocs = AtLeast(1000);
+            for (int i = 0; i < numDocs; i++)
+            {
+                idField.SetStringValue(Convert.ToString(i));
+                titleField.SetStringValue(FieldValue(1));
+                bodyField.SetStringValue(FieldValue(3));
+                iw.AddDocument(doc);
+                if (Random().Next(20) == 0)
+                {
+                    iw.DeleteDocuments(new Term("id", Convert.ToString(i)));
+                }
+            }
+            if (Random().NextBoolean())
+            {
+                // delete 1-100% of docs
+                iw.DeleteDocuments(new Term("title", Terms[Random().Next(Terms.Length)]));
+            }
+            iw.Dispose();
+            dir.Dispose(); // checkindex
+        }
+
+        internal virtual IndexOptions IndexOptions()
+        {
+            switch (Random().Next(4))
+            {
+                case 0:
+                    return Index.IndexOptions.DOCS_ONLY;
+
+                case 1:
+                    return Index.IndexOptions.DOCS_AND_FREQS;
+
+                case 2:
+                    return Index.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
+
+                default:
+                    return Index.IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
+            }
+        }
+
+        internal virtual string FieldValue(int maxTF)
+        {
+            IList<string> shuffled = new List<string>();
+            StringBuilder sb = new StringBuilder();
+            int i = Random().Next(Terms.Length);
+            while (i < Terms.Length)
+            {
+                int tf = TestUtil.NextInt(Random(), 1, maxTF);
+                for (int j = 0; j < tf; j++)
+                {
+                    shuffled.Add(Terms[i]);
+                }
+                i++;
+            }
+            Collections.Shuffle(shuffled);
+            foreach (string term in shuffled)
+            {
+                sb.Append(term);
+                sb.Append(' ');
+            }
+            return sb.ToString();
+        }
+    }
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/96822396/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
new file mode 100644
index 0000000..c78b1b4
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
@@ -0,0 +1,147 @@
+namespace Lucene.Net.Codecs.Lucene40
+{
+    using Attributes;
+    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 BaseStoredFieldsFormatTestCase = Lucene.Net.Index.BaseStoredFieldsFormatTestCase;
+
+    public class TestLucene40StoredFieldsFormat : BaseStoredFieldsFormatTestCase
+    {
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.True(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "Expecting this to be set already");
+                return new Lucene40RWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+
+        #region BaseStoredFieldsFormatTestCase
+        // 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 TestRandomStoredFields()
+        {
+            base.TestRandomStoredFields();
+        }
+
+        [Test]
+        // LUCENE-1727: make sure doc fields are stored in order
+        public override void TestStoredFieldsOrder()
+        {
+            base.TestStoredFieldsOrder();
+        }
+
+        [Test]
+        // LUCENE-1219
+        public override void TestBinaryFieldOffsetLength()
+        {
+            base.TestBinaryFieldOffsetLength();
+        }
+
+        [Test]
+        public override void TestNumericField()
+        {
+            base.TestNumericField();
+        }
+
+        [Test]
+        public override void TestIndexedBit()
+        {
+            base.TestIndexedBit();
+        }
+
+        [Test]
+        public override void TestReadSkip()
+        {
+            base.TestReadSkip();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(300000)]
+#endif
+        [Test, HasTimeout]
+        public override void TestEmptyDocs()
+        {
+            base.TestEmptyDocs();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(300000)]
+#endif
+        [Test, HasTimeout]
+        public override void TestConcurrentReads()
+        {
+            base.TestConcurrentReads();
+        }
+
+        [Test]
+        public override void TestWriteReadMerge()
+        {
+            base.TestWriteReadMerge();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(80000)]
+#endif
+        [Test, HasTimeout]
+        public override void TestBigDocuments()
+        {
+            base.TestBigDocuments();
+        }
+
+        [Test]
+        public override void TestBulkMergeWithDeletes()
+        {
+            base.TestBulkMergeWithDeletes();
+        }
+
+        #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/Lucene40/TestLucene40TermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
new file mode 100644
index 0000000..d7541eb
--- /dev/null
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
@@ -0,0 +1,117 @@
+namespace Lucene.Net.Codecs.Lucene40
+{
+    using Attributes;
+    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 BaseTermVectorsFormatTestCase = Lucene.Net.Index.BaseTermVectorsFormatTestCase;
+
+    public class TestLucene40TermVectorsFormat : BaseTermVectorsFormatTestCase
+    {
+        /// <summary>
+        /// LUCENENET specific
+        /// Is non-static because OLD_FORMAT_IMPERSONATION_IS_ACTIVE is no longer static.
+        /// </summary>
+        [OneTimeSetUp]
+        public void BeforeClass()
+        {
+            OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true; // explicitly instantiates ancient codec
+        }
+
+        protected override Codec Codec
+        {
+            get
+            {
+                Assert.True(OLD_FORMAT_IMPERSONATION_IS_ACTIVE, "Expecting this to be set already");
+                return new Lucene40RWCodec(OLD_FORMAT_IMPERSONATION_IS_ACTIVE);
+            }
+        }
+
+
+        #region BaseTermVectorsFormatTestCase
+        // 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]
+        // only one doc with vectors
+        public override void TestRareVectors()
+        {
+            base.TestRareVectors();
+        }
+
+        [Test]
+        public override void TestHighFreqs()
+        {
+            base.TestHighFreqs();
+        }
+
+        [Test]
+        public override void TestLotsOfFields()
+        {
+            base.TestLotsOfFields();
+        }
+
+#if !NETSTANDARD
+        // LUCENENET: There is no Timeout on NUnit for .NET Core.
+        [Timeout(300000)]
+#endif
+        [Test, HasTimeout]
+        // different options for the same field
+        public override void TestMixedOptions()
+        {
+            base.TestMixedOptions();
+        }
+
+        [Test]
+        public override void TestRandom()
+        {
+            base.TestRandom();
+        }
+
+        [Test]
+        public override void TestMerge()
+        {
+            base.TestMerge();
+        }
+
+        [Test]
+        // run random tests from different threads to make sure the per-thread clones
+        // don't share mutable data
+        public override void TestClone()
+        {
+            base.TestClone();
+        }
+
+        #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


Mime
View raw message