Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 5D50E200BE4 for ; Tue, 6 Dec 2016 16:11:46 +0100 (CET) Received: by cust-asf.ponee.io (Postfix) id 5C0D7160B1B; Tue, 6 Dec 2016 15:11:46 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id E795C160B0C for ; Tue, 6 Dec 2016 16:11:43 +0100 (CET) Received: (qmail 55883 invoked by uid 500); 6 Dec 2016 15:11:40 -0000 Mailing-List: contact commits-help@lucenenet.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: lucene-net-dev@lucenenet.apache.org Delivered-To: mailing list commits@lucenenet.apache.org Received: (qmail 55472 invoked by uid 99); 6 Dec 2016 15:11:40 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 06 Dec 2016 15:11:40 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 1DBCFE0C09; Tue, 6 Dec 2016 15:11:39 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: nightowl888@apache.org To: commits@lucenenet.apache.org Date: Tue, 06 Dec 2016 15:12:30 -0000 Message-Id: In-Reply-To: <4ec64ecbc83b463ba620eb199f52fe93@git.apache.org> References: <4ec64ecbc83b463ba620eb199f52fe93@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [55/58] lucenenet git commit: HACK: (4th) Added stubs for all tests subclasses of abstract test classes (with [Test] attributes) and commented the [Test] attributes in the abstract classes to keep the tests from running in the wrong context. archived-at: Tue, 06 Dec 2016 15:11:46 -0000 http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Codecs/Lucene42/TestLucene42DocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene42/TestLucene42DocValuesFormat.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene42/TestLucene42DocValuesFormat.cs index 7f4438b..598f373 100644 --- a/src/Lucene.Net.Tests/core/Codecs/Lucene42/TestLucene42DocValuesFormat.cs +++ b/src/Lucene.Net.Tests/core/Codecs/Lucene42/TestLucene42DocValuesFormat.cs @@ -51,5 +51,531 @@ namespace Lucene.Net.Codecs.Lucene42 { return false; } + + + #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(); + } + + /// + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// + /// Tests dv against stored fields with threads (all types + missing) + /// + [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/701b9ed2/src/Lucene.Net.Tests/core/Codecs/Lucene45/TestLucene45DocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Codecs/Lucene45/TestLucene45DocValuesFormat.cs b/src/Lucene.Net.Tests/core/Codecs/Lucene45/TestLucene45DocValuesFormat.cs index 2ce76f3..dc18580 100644 --- a/src/Lucene.Net.Tests/core/Codecs/Lucene45/TestLucene45DocValuesFormat.cs +++ b/src/Lucene.Net.Tests/core/Codecs/Lucene45/TestLucene45DocValuesFormat.cs @@ -1,3 +1,5 @@ +using NUnit.Framework; + namespace Lucene.Net.Codecs.Lucene45 { /* @@ -34,5 +36,530 @@ namespace Lucene.Net.Codecs.Lucene45 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(); + } + + /// + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// + /// Tests dv against stored fields with threads (all types + missing) + /// + [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/701b9ed2/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldDocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldDocValuesFormat.cs index bf0a5fe..cbf656c 100644 --- a/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldDocValuesFormat.cs +++ b/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldDocValuesFormat.cs @@ -153,5 +153,506 @@ namespace Lucene.Net.Codecs.Perfield } } } + + + #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(); + } + + /// + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// + /// Tests dv against stored fields with threads (all types + missing) + /// + [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/701b9ed2/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldPostingsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldPostingsFormat.cs b/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldPostingsFormat.cs index d2275e8..05751f9 100644 --- a/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldPostingsFormat.cs +++ b/src/Lucene.Net.Tests/core/Codecs/Perfield/TestPerFieldPostingsFormat.cs @@ -45,5 +45,56 @@ namespace Lucene.Net.Codecs.Perfield //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/701b9ed2/src/Lucene.Net.Tests/core/Index/TestDocValuesFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestDocValuesFormat.cs b/src/Lucene.Net.Tests/core/Index/TestDocValuesFormat.cs index 70ee586..628ddc0 100644 --- a/src/Lucene.Net.Tests/core/Index/TestDocValuesFormat.cs +++ b/src/Lucene.Net.Tests/core/Index/TestDocValuesFormat.cs @@ -1,3 +1,5 @@ +using NUnit.Framework; + namespace Lucene.Net.Index { /* @@ -39,5 +41,506 @@ namespace Lucene.Net.Index { return TestUtil.FieldSupportsHugeBinaryDocValues(field); } + + + #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(); + } + + /// + /// Tests dv against stored fields with threads (binary/numeric/sorted, no missing) + /// + [Test] + public override void TestThreads() + { + base.TestThreads(); + } + + /// + /// Tests dv against stored fields with threads (all types + missing) + /// + [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/701b9ed2/src/Lucene.Net.Tests/core/Index/TestLogMergePolicy.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestLogMergePolicy.cs b/src/Lucene.Net.Tests/core/Index/TestLogMergePolicy.cs index e99678b..921b719 100644 --- a/src/Lucene.Net.Tests/core/Index/TestLogMergePolicy.cs +++ b/src/Lucene.Net.Tests/core/Index/TestLogMergePolicy.cs @@ -1,3 +1,5 @@ +using NUnit.Framework; + namespace Lucene.Net.Index { /* @@ -23,5 +25,18 @@ namespace Lucene.Net.Index { return NewLogMergePolicy(Random()); } + + #region BaseMergePolicyTestCase + // 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 TestForceMergeNotNeeded() + { + base.TestForceMergeNotNeeded(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs b/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs index 7f425f7..c48b98f 100644 --- a/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs +++ b/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs @@ -1527,7 +1527,7 @@ namespace Lucene.Net.Index dir.Dispose(); } - [Test] + [Test, Timeout(120000)] public virtual void TestTonsOfUpdates() { // LUCENE-5248: make sure that when there are many updates, we don't use too much RAM http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Index/TestPersistentSnapshotDeletionPolicy.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestPersistentSnapshotDeletionPolicy.cs b/src/Lucene.Net.Tests/core/Index/TestPersistentSnapshotDeletionPolicy.cs index 70c47cc..7d49c1b 100644 --- a/src/Lucene.Net.Tests/core/Index/TestPersistentSnapshotDeletionPolicy.cs +++ b/src/Lucene.Net.Tests/core/Index/TestPersistentSnapshotDeletionPolicy.cs @@ -208,5 +208,55 @@ namespace Lucene.Net.Index Assert.AreEqual(0, psdp.SnapshotCount, "Should have no snapshots !"); dir.Dispose(); } + + + #region TestSnapshotDeletionPolicy + // LUCENENET NOTE: Tests in a 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 TestSnapshotDeletionPolicy_Mem() + { + base.TestSnapshotDeletionPolicy_Mem(); + } + + [Test] + public override void TestBasicSnapshots() + { + base.TestBasicSnapshots(); + } + + [Test] + public override void TestMultiThreadedSnapshotting() + { + base.TestMultiThreadedSnapshotting(); + } + + [Test] + public override void TestRollbackToOldSnapshot() + { + base.TestRollbackToOldSnapshot(); + } + + [Test] + public override void TestReleaseSnapshot() + { + base.TestReleaseSnapshot(); + } + + [Test] + public override void TestSnapshotLastCommitTwice() + { + base.TestSnapshotLastCommitTwice(); + } + + [Test] + public override void TestMissingCommits() + { + base.TestMissingCommits(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Index/TestPostingsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestPostingsFormat.cs b/src/Lucene.Net.Tests/core/Index/TestPostingsFormat.cs index 427aa96..20c6b07 100644 --- a/src/Lucene.Net.Tests/core/Index/TestPostingsFormat.cs +++ b/src/Lucene.Net.Tests/core/Index/TestPostingsFormat.cs @@ -41,5 +41,55 @@ namespace Lucene.Net.Index { 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/701b9ed2/src/Lucene.Net.Tests/core/Index/TestStoredFieldsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestStoredFieldsFormat.cs b/src/Lucene.Net.Tests/core/Index/TestStoredFieldsFormat.cs index 902db7f..31ed10c 100644 --- a/src/Lucene.Net.Tests/core/Index/TestStoredFieldsFormat.cs +++ b/src/Lucene.Net.Tests/core/Index/TestStoredFieldsFormat.cs @@ -47,5 +47,88 @@ namespace Lucene.Net.Index // and merge into newly formed 3.x segments. base.TestWriteReadMerge(); } + + + #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(); + } + + [Test, Timeout(120000)] + 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/701b9ed2/src/Lucene.Net.Tests/core/Index/TestTermVectorsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestTermVectorsFormat.cs b/src/Lucene.Net.Tests/core/Index/TestTermVectorsFormat.cs index 38f08d4..dac8fa8 100644 --- a/src/Lucene.Net.Tests/core/Index/TestTermVectorsFormat.cs +++ b/src/Lucene.Net.Tests/core/Index/TestTermVectorsFormat.cs @@ -58,5 +58,60 @@ namespace Lucene.Net.Index { AssumeTrue("The MockRandom PF randomizes content on the fly, so we can't check it", false); } + + + + #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(); + } + + [Test] + // 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 } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Index/TestTieredMergePolicy.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Index/TestTieredMergePolicy.cs b/src/Lucene.Net.Tests/core/Index/TestTieredMergePolicy.cs index 922551c..ede9691 100644 --- a/src/Lucene.Net.Tests/core/Index/TestTieredMergePolicy.cs +++ b/src/Lucene.Net.Tests/core/Index/TestTieredMergePolicy.cs @@ -273,5 +273,19 @@ namespace Lucene.Net.Index // TODO: Add more checks for other non-double setters! } + + + #region BaseMergePolicyTestCase + // 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 TestForceMergeNotNeeded() + { + base.TestForceMergeNotNeeded(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/BaseTestRangeFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/BaseTestRangeFilter.cs b/src/Lucene.Net.Tests/core/Search/BaseTestRangeFilter.cs index 96ec2f4..16a6d17 100644 --- a/src/Lucene.Net.Tests/core/Search/BaseTestRangeFilter.cs +++ b/src/Lucene.Net.Tests/core/Search/BaseTestRangeFilter.cs @@ -192,7 +192,7 @@ namespace Lucene.Net.Search } } - [Test] + // [Test] // LUCENENET NOTE: For now, we are overriding this test in every subclass to pull it into the right context for the subclass public virtual void TestPad() { int[] tests = new int[] { -9999999, -99560, -100, -3, -1, 0, 3, 9, 10, 1000, 999999999 }; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/Spans/TestSpanExplanationsOfNonMatches.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/Spans/TestSpanExplanationsOfNonMatches.cs b/src/Lucene.Net.Tests/core/Search/Spans/TestSpanExplanationsOfNonMatches.cs index 735dc0c..307c51f 100644 --- a/src/Lucene.Net.Tests/core/Search/Spans/TestSpanExplanationsOfNonMatches.cs +++ b/src/Lucene.Net.Tests/core/Search/Spans/TestSpanExplanationsOfNonMatches.cs @@ -33,5 +33,219 @@ namespace Lucene.Net.Search.Spans { CheckHits.CheckNoMatchExplanations(q, FIELD, Searcher, expDocNrs); } + + + #region TestSpanExplanations + // LUCENENET NOTE: Tests in a 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 TestST1() + { + base.TestST1(); + } + + [Test] + public override void TestST2() + { + base.TestST2(); + } + + [Test] + public override void TestST4() + { + base.TestST4(); + } + + [Test] + public override void TestST5() + { + base.TestST5(); + } + + /* some SpanFirstQueries */ + + [Test] + public override void TestSF1() + { + base.TestSF1(); + } + + [Test] + public override void TestSF2() + { + base.TestSF2(); + } + + [Test] + public override void TestSF4() + { + base.TestSF4(); + } + + [Test] + public override void TestSF5() + { + base.TestSF5(); + } + + [Test] + public override void TestSF6() + { + base.TestSF6(); + } + + /* some SpanOrQueries */ + + [Test] + public override void TestSO1() + { + base.TestSO1(); + } + + [Test] + public override void TestSO2() + { + base.TestSO2(); + } + + [Test] + public override void TestSO3() + { + base.TestSO3(); + } + + [Test] + public override void TestSO4() + { + base.TestSO4(); + } + + /* some SpanNearQueries */ + + [Test] + public override void TestSNear1() + { + base.TestSNear1(); + } + + [Test] + public override void TestSNear2() + { + base.TestSNear2(); + } + + [Test] + public override void TestSNear3() + { + base.TestSNear3(); + } + + [Test] + public override void TestSNear4() + { + base.TestSNear4(); + } + + [Test] + public override void TestSNear5() + { + base.TestSNear5(); + } + + [Test] + public override void TestSNear6() + { + base.TestSNear6(); + } + + [Test] + public override void TestSNear7() + { + base.TestSNear7(); + } + + [Test] + public override void TestSNear8() + { + base.TestSNear8(); + } + + [Test] + public override void TestSNear9() + { + base.TestSNear9(); + } + + [Test] + public override void TestSNear10() + { + base.TestSNear10(); + } + + [Test] + public override void TestSNear11() + { + base.TestSNear11(); + } + + /* some SpanNotQueries */ + + [Test] + public override void TestSNot1() + { + base.TestSNot1(); + } + + [Test] + public override void TestSNot2() + { + base.TestSNot2(); + } + + [Test] + public override void TestSNot4() + { + base.TestSNot4(); + } + + [Test] + public override void TestSNot5() + { + base.TestSNot5(); + } + + [Test] + public override void TestSNot7() + { + base.TestSNot7(); + } + + [Test] + public override void TestSNot10() + { + base.TestSNot10(); + } + + #endregion + + #region TestExplanations + // 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. + + + /// + /// Placeholder: JUnit freaks if you don't have one test ... making + /// class abstract doesn't help + /// + [Test] + public override void TestNoop() + { + base.TestNoop(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestComplexExplanationsOfNonMatches.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestComplexExplanationsOfNonMatches.cs b/src/Lucene.Net.Tests/core/Search/TestComplexExplanationsOfNonMatches.cs index fbfe049..18a2759 100644 --- a/src/Lucene.Net.Tests/core/Search/TestComplexExplanationsOfNonMatches.cs +++ b/src/Lucene.Net.Tests/core/Search/TestComplexExplanationsOfNonMatches.cs @@ -33,5 +33,165 @@ namespace Lucene.Net.Search { CheckHits.CheckNoMatchExplanations(q, FIELD, Searcher, expDocNrs); } + + + #region TestComplexExplanations + // LUCENENET NOTE: Tests in a 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 Test1() + { + base.Test1(); + } + + [Test] + public override void Test2() + { + base.Test2(); + } + + // :TODO: we really need more crazy complex cases. + + // ////////////////////////////////////////////////////////////////// + + // The rest of these aren't that complex, but they are somewhat + // complex, and they expose weakness in dealing with queries that match + // with scores of 0 wrapped in other queries + + [Test] + public override void TestT3() + { + base.TestT3(); + } + + [Test] + public override void TestMA3() + { + base.TestMA3(); + } + + [Test] + public override void TestFQ5() + { + base.TestFQ5(); + } + + [Test] + public override void TestCSQ4() + { + base.TestCSQ4(); + } + + [Test] + public override void TestDMQ10() + { + base.TestDMQ10(); + } + + [Test] + public override void TestMPQ7() + { + base.TestMPQ7(); + } + + [Test] + public override void TestBQ12() + { + base.TestBQ12(); + } + + [Test] + public override void TestBQ13() + { + base.TestBQ13(); + } + + [Test] + public override void TestBQ18() + { + base.TestBQ18(); + } + + [Test] + public override void TestBQ21() + { + base.TestBQ21(); + } + + [Test] + public override void TestBQ22() + { + base.TestBQ22(); + } + + [Test] + public override void TestST3() + { + base.TestST3(); + } + + [Test] + public override void TestST6() + { + base.TestST6(); + } + + [Test] + public override void TestSF3() + { + base.TestSF3(); + } + + [Test] + public override void TestSF7() + { + base.TestSF7(); + } + + [Test] + public override void TestSNot3() + { + base.TestSNot3(); + } + + [Test] + public override void TestSNot6() + { + base.TestSNot6(); + } + + [Test] + public override void TestSNot8() + { + base.TestSNot8(); + } + + [Test] + public override void TestSNot9() + { + base.TestSNot9(); + } + + #endregion + + #region TestExplanations + // 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. + + + /// + /// Placeholder: JUnit freaks if you don't have one test ... making + /// class abstract doesn't help + /// + [Test] + public override void TestNoop() + { + base.TestNoop(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestExplanations.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestExplanations.cs b/src/Lucene.Net.Tests/core/Search/TestExplanations.cs index a528615..18962f9 100644 --- a/src/Lucene.Net.Tests/core/Search/TestExplanations.cs +++ b/src/Lucene.Net.Tests/core/Search/TestExplanations.cs @@ -261,7 +261,7 @@ namespace Lucene.Net.Search /// Placeholder: JUnit freaks if you don't have one test ... making /// class abstract doesn't help /// - [Test] + // [Test] // LUCENENET NOTE: For now, we are overriding this test in every subclass to pull it into the right context for the subclass public virtual void TestNoop() { /* NOOP */ http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs index cc0d022..f0e44a8 100644 --- a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs +++ b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs @@ -590,5 +590,19 @@ namespace Lucene.Net.Search reader.Dispose(); dir.Dispose(); } + + + #region SorterTestBase + // LUCENENET NOTE: Tests in a 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 TestPad() + { + base.TestPad(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestFieldCacheRewriteMethod.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRewriteMethod.cs b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRewriteMethod.cs index 0fc6843..1b923a3 100644 --- a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRewriteMethod.cs +++ b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRewriteMethod.cs @@ -60,5 +60,22 @@ namespace Lucene.Net.Search Assert.IsFalse(a1.Equals(b)); QueryUtils.Check(a1); } + + + + #region TestSnapshotDeletionPolicy + // LUCENENET NOTE: Tests in a 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 a bunch of random regular expressions + [Test, Timeout(60000)] + public override void TestRegexps() + { + base.TestRegexps(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestMultiTermConstantScore.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiTermConstantScore.cs b/src/Lucene.Net.Tests/core/Search/TestMultiTermConstantScore.cs index f52d360..7f95d2a 100644 --- a/src/Lucene.Net.Tests/core/Search/TestMultiTermConstantScore.cs +++ b/src/Lucene.Net.Tests/core/Search/TestMultiTermConstantScore.cs @@ -551,5 +551,19 @@ namespace Lucene.Net.Search result = search.Search(Csrq("rand", maxRP, null, T, F), null, numDocs).ScoreDocs; AssertEquals("max,nul,T,T", 1, result.Length); } + + + #region SorterTestBase + // LUCENENET NOTE: Tests in a 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 TestPad() + { + base.TestPad(); + } + + #endregion } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/lucenenet/blob/701b9ed2/src/Lucene.Net.Tests/core/Search/TestSimpleExplanations.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Tests/core/Search/TestSimpleExplanations.cs b/src/Lucene.Net.Tests/core/Search/TestSimpleExplanations.cs index 304a837..5fec12f 100644 --- a/src/Lucene.Net.Tests/core/Search/TestSimpleExplanations.cs +++ b/src/Lucene.Net.Tests/core/Search/TestSimpleExplanations.cs @@ -927,5 +927,24 @@ namespace Lucene.Net.Search Qtest(query, new int[] { 0, 1, 2, 3 }); } + + + #region TestExplanations + // 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. + + + /// + /// Placeholder: JUnit freaks if you don't have one test ... making + /// class abstract doesn't help + /// + [Test] + public override void TestNoop() + { + base.TestNoop(); + } + + #endregion } } \ No newline at end of file