Class LuceneTestCase

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

TODO: javadoc?

Type	Description
string

Type	Description
string

Suite failure marker (any error in the test or suite scope).

Type	Description
bool

Use this constant when creating Analyzers and any other version-dependent stuff.

NOTE: Change this when development starts for new Lucene version:

Type	Description
LuceneVersion

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Description
bool

Returns true if the codec "supports" docsWithField (other codecs return MatchAllBits, because you couldnt write missing values before)

Type	Description
bool

Returns true if the codec "supports" field updates.

Type	Description
bool

Returns true if the default codec supports single valued docvalues with missing values

Type	Description
bool

Returns true if the default codec supports SORTED_SET docvalues

Type	Description
bool

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Description
ICollection<string>

Leave temporary files on disk, even on successful runs.

Type	Description
bool

When true, Codecs for old Lucene version will support writing indexes in that format. Defaults to false, can be disabled by specific tests on demand.

Note

This API is for internal purposes only and might change in incompatible ways in the next release.

Type	Description
bool

Access to the current Random instance. It is safe to use this method from multiple threads, etc., but it should be called while within a runner's scope (so no static initializers). The returned Random instance will be different when this method is called inside a BeforeClass() hook (static suite scope) and within NUnit.Framework.SetUpAttribute/ NUnit.Framework.TearDownAttribute hooks or test methods.

The returned instance must not be shared with other threads or cross a single scope's boundary. For example, a Random acquired within a test method shouldn't be reused for another test case.

There is an overhead connected with getting the Random for a particular context and thread. It is better to cache the Random locally if tight loops with multiple invocations are present or create a derivative local Random for millions of calls like this:

Random random = new J2N.Randomizer(Random.NextInt64());
// tight loop with many invocations.

Type	Description
Random

A random multiplier which you should use when writing random tests: multiply it by the number of iterations to scale your tests (for nightly builds).

Type	Description
int

Whether or not LuceneTestCase.AwaitsFixAttribute tests should run.

Type	Description
bool

Gets the codec to run tests with.

Type	Description
string

Gets the directory to run tests with

Type	Description
string

Gets the docValuesFormat to run tests with

Type	Description
string

The line file used by LineFileDocs

Type	Description
string

Return the name of the currently executing test case.

Type	Description
string

Whether or not LuceneTestCase.NightlyAttribute tests should run.

Type	Description
bool

Gets the postingsFormat to run tests with.

Type	Description
string

Whether or not LuceneTestCase.SlowAttribute tests should run.

Type	Description
bool

Gets the current type being tested.

Type	Description
Type

Whether or not LuceneTestCase.WeeklyAttribute tests should run.

Type	Description
bool

TODO: javadoc?

Type	Description
bool

True if and only if tests are run in verbose mode. If this flag is false tests are not expected to print any messages.

Type	Description
bool

Tears down random defaults and cleans up temporary files.

If you override this method, be sure to call base.AfterClass() AFTER tearing down your test fixture.

Return args as a ISet<T> instance. The order of elements is not preserved in enumerators.

Type	Name	Description
object[]	args

Type	Description
ISet<object>

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Checks that docvalues across all fields are equivalent.

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Name	Description
string	info
int	num
NumericDocValues	leftDocValues
NumericDocValues	rightDocValues

Checks docs + freqs + positions + payloads, sequentially.

Type	Name	Description
string	info
DocsAndPositionsEnum	leftDocs
DocsAndPositionsEnum	rightDocs

Checks docs + freqs, sequentially.

Type	Name	Description
string	info
DocsEnum	leftDocs
DocsEnum	rightDocs
bool	hasFreqs

Checks advancing docs.

Type	Name	Description
string	info
IndexReader	leftReader
int	docFreq
DocsEnum	leftDocs
DocsEnum	rightDocs
bool	hasFreqs

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Checks that top-level statistics on Lucene.Net.Index.Fields are the same.

Type	Name	Description
string	info
Fields	leftFields
Fields	rightFields

Fields API equivalency.

Type	Name	Description
string	info
IndexReader	leftReader
Fields	leftFields
Fields	rightFields
bool	deep

Checks that norms are the same across all fields.

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Checks advancing docs + positions.

Type	Name	Description
string	info
IndexReader	leftReader
int	docFreq
DocsAndPositionsEnum	leftDocs
DocsAndPositionsEnum	rightDocs

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Checks that reader-level statistics are the same.

Type	Name	Description
string	info
IndexReader	leftReader
IndexReader	rightReader

Asserts that Lucene.Net.Util.FieldCacheSanityChecker does not detect any problems with Lucene.Net.Search.FieldCache.DEFAULT.

If any problems are found, they are logged to Lucene.Net.Util.SystemConsole.Error (allong with the msg) when the Assertion is thrown.

This method is called by TearDown() after every test method, however Lucene.Net.Index.IndexReaders scoped inside test methods may be garbage collected prior to this method being called, causing errors to be overlooked. Tests are encouraged to keep their Lucene.Net.Index.IndexReaders scoped at the class level, or to explicitly call this method directly in the same scope as the Lucene.Net.Index.IndexReader.

Type	Name	Description
string	msg

Checks that two stored fields are equivalent.

Checks that stored fields of all documents are the same.

Checks term-level statistics.

Checks that term vectors across all fields are equivalent.

Checks the terms enum sequentially. If deep is false, it does a 'shallow' test that doesnt go down to the docsenums.

Lucene.Net.Index.Terms API equivalency.

Checks collection-level statistics on Lucene.Net.Index.Terms.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Assume e is null.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Returns a number of at least i

The actual number returned will be influenced by whether TestNightly is active and RandomMultiplier, but also with some random fudge.

Sets up dependency injection of codec factories for running the test class, and also picks random defaults for culture, time zone, similarity, and default codec.

If you override this method, be sure to call base.BeforeClass() BEFORE setting up your test fixture.

Creates an empty, temporary folder (when the name of the folder is of no importance).

Creates an empty, temporary folder with the given name prefix under the system's GetTempPath() or if supplied, the tempDir system property.

The folder will be automatically removed after the test class completes successfully. The test should close any file handles that would prevent the folder from being removed.

Creates an empty temporary file.

The file will be automatically removed after the test class completes successfully. The test should close any file handles that would prevent the file from being removed.

Creates an empty file with the given prefix and suffix under the system's GetTempPath() or if supplied, the tempDir system property.

The file will be automatically removed after the test class completes successfully. The test should close any file handles that would prevent the file from being removed.

return a CultureInfo object equivalent to its programmatic name.

Convenience method for logging an array. Wraps the array in an enumerator and delegates to DumpEnumerator(string, IEnumerator, TextWriter)

Convenience method for logging an enumerator.

Gets a resource from the classpath as Stream. This method should only be used, if a real file is needed. To get a stream, code should prefer FindAndGetManifestResourceStream(Assembly, Type, string) using this.GetType().Assembly and this.GetType().

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Some tests expect the directory to contain a single segment, and want to do tests on that segment's reader. This is an utility method to help them.

Sometimes wrap the Lucene.Net.Index.IndexReader as slow, parallel or filter reader (or combinations of that)

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Returns a new Lucene.Net.Store.Directory instance. Use this when the test does not care about the specific Lucene.Net.Store.Directory implementation (most tests).

The Lucene.Net.Store.Directory is wrapped with BaseDirectoryWrapper. This means usually it will be picky, such as ensuring that you properly dispose it and close all open files in your test. It will emulate some features of Windows, such as not allowing open files to be overwritten.

Returns a new Lucene.Net.Store.Directory instance, with contents copied from the provided directory. See NewDirectory() for more information.

Returns a new Lucene.Net.Store.Directory instance, using the specified random. See NewDirectory() for more information.

Returns a new Lucene.Net.Store.Directory instance, using the specified random with contents copied from the provided directory. See NewDirectory() for more information.

Returns a new Lucene.Net.Store.FSDirectory instance over the given file, which must be a folder.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

TODO: javadoc

Create a new Lucene.Net.Index.IndexWriterConfig with random defaults.

Create a new Lucene.Net.Index.IndexWriterConfig with random defaults using the specified random.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Create a new searcher over the reader. this searcher might randomly use threads.

Create a new searcher over the reader. This searcher might randomly use threads.

Create a new searcher over the reader. This searcher might randomly use threads. If maybeWrap is true, this searcher might wrap the reader with one that returns null for Lucene.Net.Index.CompositeReader.GetSequentialSubReaders(). If wrapWithAssertions is true, this searcher might be an AssertingIndexSearcher instance.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Return a random CultureInfo from the available cultures on the system.

See https://issues.apache.org/jira/browse/LUCENE-4020.

Returns the next pseudorandom, Gaussian ("normally") distributed double value with mean 0.0 and standard deviation 1.0 from this random number generator's sequence.

The general contract of RandomGaussian() is that one double value, chosen from (approximately) the usual normal distribution with mean 0.0 and standard deviation 1.0, is pseudorandomly generated and returned.

This uses the polar method of G. E. P. Box, M. E. Muller, and G. Marsaglia, as described by Donald E. Knuth in The Art of Computer Programming, Volume 3: Seminumerical Algorithms, section 3.4.1, subsection C, algorithm P. Note that it generates two independent values at the cost of only one call to Log(double) and one call to Sqrt(double).

Return a random TimeZoneInfo from the available timezones on the system

See https://issues.apache.org/jira/browse/LUCENE-4020.

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Returns true if something should happen rarely,

The actual number returned will be influenced by whether TestNightly is active and RandomMultiplier.

For subclasses to override. Overrides must call base.SetUp().

Returns true if the file exists (can be opened), false if it cannot be opened, and (unlike .NET's Exists(string)) if there's some unexpected error, returns false.

For subclasses to override. Overrides must call base.TearDown().

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Base class for all Lucene.Net unit tests.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with NUnit.Framework.OneTimeSetUpAttribute and NUnit.Framework.OneTimeTearDownAttribute. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex readonly field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use NUnit.Framework.SetUpAttribute and NUnit.Framework.TearDownAttribute annotated methods. If you override either SetUp() or TearDown() in your subclass, make sure you call base.SetUp() and base.TearDown(). This is detected and enforced.

Specifying test cases

Any test method annotated with NUnit.Framework.TestAttribute is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses a custom LuceneTestCase.TestFixtureAttribute to execute test cases. The custom LuceneTestCase.TestFixtureAttribute has built-in support for test randomization including access to a repeatable Random instance. See Random property. Any test using Random acquired from Random should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in the failure test message.

The seed can be configured with a RunSettings file, a lucene.testsettings.json JSON file, an environment variable, or using RandomSeedAttribute at the assembly level. It is recommended to configure the culture also, since they are randomly picked from a list of cultures installed on a given machine, so the culture will vary from one machine to the next.

.runsettings File Configuration Example

<RunSettings>
                                                             <TestRunParameters>
                                                               <Parameter name="tests:seed" value="0x1ffa1d067056b0e6" />
                                                               <Parameter name="tests:culture" value="sw-TZ" />
                                                             </TestRunParameters>
                                                           </RunSettings>

See the .runsettings documentation at: https://docs.microsoft.com/en-us/visualstudio/test/configure-unit-tests-by-using-a-dot-runsettings-file.

Attribute Configuration Example

[assembly: Lucene.Net.Util.RandomSeed("0x1ffa1d067056b0e6")]
                                            [assembly: NUnit.Framework.SetCulture("sw-TZ")]

lucene.testsettings.json File Configuration Example

Add a file named lucene.testsettings.json to the executable directory or any directory between the executable and the root of the drive with the following contents.

{
      "tests": {
        "seed": "0x1ffa1d067056b0e6",
        "culture": "sw-TZ"
      }
    }

Environment Variable Configuration Example

Variable	Value
lucene:tests:seed	0x1ffa1d067056b0e6
lucene:tests:culture	sw-TZ

Type	Name	Description
string	msg	Message to be included in the exception's string.
bool	condition	If `true` an NUnit.Framework.InconclusiveException is thrown by this method and the test case (should be) ignored (or rather technically, flagged as a failure not passing a certain assumption). Tests that are assumption-failures do not break builds (again: typically).

Type	Name	Description
string	label	String logged before/after the items in the enumerator.
IEnumerator	iter	Each element is ToString()ed and logged on it's own line. If iter is null this is logged differnetly then an empty enumerator.
TextWriter	stream	Stream to log messages to.

Type	Name	Description
Random	random	A random instance (usually Random).
LuceneVersion	v
Analyzer	a

Class and instance setup.

Specifying test cases

Randomized execution and test facilities

.runsettings File Configuration Example

Attribute Configuration Example

lucene.testsettings.json File Configuration Example

Environment Variable Configuration Example

Inheritance

Inherited Members

Namespace: Lucene.Net.Util

Assembly: Lucene.Net.TestFramework.dll

Syntax

Fields

DEFAULT_LINE_DOCS_FILE

Declaration

Field Value

JENKINS_LARGE_LINE_DOCS_FILE

Declaration

Field Value

SuiteFailureMarker

Declaration

Field Value

TEST_VERSION_CURRENT

Declaration

Field Value

Properties

DefaultCodecSupportsDocValues

Class and instance setup.

Specifying test cases

Randomized execution and test facilities

.runsettings File Configuration Example

Attribute Configuration Example

lucene.testsettings.json File Configuration Example

Environment Variable Configuration Example

Declaration

Property Value

DefaultCodecSupportsDocsWithField

Declaration

Property Value

DefaultCodecSupportsFieldUpdates

Declaration

Property Value

DefaultCodecSupportsMissingDocValues

Declaration

Property Value

DefaultCodecSupportsSortedSet

Declaration

Property Value

DoesntSupportOffsets

Class and instance setup.

Specifying test cases

Randomized execution and test facilities

.runsettings File Configuration Example

Attribute Configuration Example

lucene.testsettings.json File Configuration Example

Environment Variable Configuration Example

Declaration

Property Value

LeaveTemporary

Declaration

Property Value

OldFormatImpersonationIsActive

Note

Declaration

Property Value

Random

Declaration

Property Value

RandomMultiplier

Declaration

Property Value

TestAwaitsFix

Declaration

Property Value

TestCodec

Declaration

Property Value

TestDirectory

Declaration