You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2020/08/24 18:29:47 UTC

[lucenenet] branch master updated (94a3e1e -> e8bc15f)

This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git.


    from 94a3e1e  Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter: Removed invalid comment
     new ee8d8e8  Lucene.Net.Diagnostics: Moved AssertionException from test framework to Lucene.Net assembly
     new 4b3a849  Lucene.Net.Diagnostics: Added static Debugging.Assert() overloads to allow assertions to be turned on and off in the Release build
     new 8de6714  Converted all non-test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()
     new 8aa7108  Converted test framework to use Lucene.Net.Diagnostics.Debugging.Assert() instead of Lucene.Net.Diagnostics.Debug.Assert()
     new a9eb0c8  Converted all test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()
     new 447bc86  SWEEP: Reviewed and added missing asserts and moved some assert conditions to be not run when asserts are disabled
     new 8a7f282  Added if (Debugging.AssertsEnabled) blocks to improve performance when asserts are disabled
     new 9caee94  Lucene.Net.Diagnostics.Debugging: Changed AssertsEnabled to a static field
     new a758ffa  Changed all Debugging.Assert() overloads to use bool instead of Func<bool>
     new c3a53c3  Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase: Fixed issue with reflection not finding the method due to the Func<string> parameter of Debugging.Assert()
     new 3ddf3df  Codecs: Reverted term vectors readers to use InvalidOperationException always instead of AssertionException only when assert is enabled
     new 4b31e7c  Lucene.Net.Tests: Don't run tests that require asserts unless asserts are enabled. (closes #326, see #313)
     new e8bc15f  azure-pipelines.yml: Added option to disable asserts when running tests

The 13 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 azure-pipelines.yml                                |  29 +--
 .../Analysis/CharFilter/BaseCharFilter.cs          |   6 +-
 .../Analysis/CharFilter/HTMLStripCharFilter.cs     |  23 ++-
 .../Analysis/CharFilter/MappingCharFilter.cs       |   3 +-
 .../Analysis/CharFilter/NormalizeCharMap.cs        |   6 +-
 .../Compound/CompoundWordTokenFilterBase.cs        |   4 +-
 .../Analysis/Gl/GalicianStemmer.cs                 |   6 +-
 .../Analysis/Hunspell/Dictionary.cs                |  10 +-
 .../Analysis/Hunspell/Stemmer.cs                   |   6 +-
 .../Analysis/Miscellaneous/ASCIIFoldingFilter.cs   |   6 +-
 .../Miscellaneous/SingleTokenTokenStream.cs        |   5 +-
 .../Analysis/NGram/NGramTokenizer.cs               |   5 +-
 .../Pattern/PatternCaptureGroupTokenFilter.cs      |   3 +-
 .../Analysis/Pt/PortugueseStemmer.cs               |   4 +-
 .../Analysis/Pt/RSLPStemmerBase.cs                 |   3 +-
 .../Analysis/Synonym/SynonymFilter.cs              |  20 +-
 .../Analysis/Synonym/SynonymMap.cs                 |  10 +-
 .../Analysis/Util/CharArrayMap.cs                  |   6 +-
 .../Analysis/Util/CharTokenizer.cs                 |   8 +-
 .../Analysis/Util/CharacterUtils.cs                |  33 ++-
 .../Analysis/Util/RollingCharBuffer.cs             |  32 ++-
 .../Analysis/Util/SegmentingTokenizerBase.cs       |   3 +-
 .../Analysis/Util/StemmerUtil.cs                   |   7 +-
 .../Analysis/Icu/ICUNormalizer2CharFilter.cs       |   3 +-
 .../Analysis/Icu/Segmentation/ICUTokenizer.cs      |   3 +-
 .../Icu/Segmentation/ICUTokenizerFactory.cs        |   5 +-
 .../Dict/TokenInfoFST.cs                           |   5 +-
 .../GraphvizFormatter.cs                           |   9 +-
 .../JapaneseIterationMarkCharFilter.cs             |   4 +-
 .../JapaneseTokenizer.cs                           |  41 ++--
 .../Tools/BinaryDictionaryWriter.cs                |  29 +--
 .../Tools/ConnectionCostsBuilder.cs                |   8 +-
 .../Tools/ConnectionCostsWriter.cs                 |   5 +-
 .../BeiderMorseFilter.cs                           |   4 +-
 .../ByTask/Utils/AnalyzerFactory.cs                |   4 +-
 src/Lucene.Net.Benchmark/Quality/QualityStats.cs   |   3 +-
 src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs |   3 +-
 .../BlockTerms/BlockTermsReader.cs                 |  36 ++--
 .../BlockTerms/BlockTermsWriter.cs                 |  17 +-
 .../BlockTerms/FixedGapTermsIndexReader.cs         |  28 +--
 .../BlockTerms/FixedGapTermsIndexWriter.cs         |   3 +-
 .../BlockTerms/VariableGapTermsIndexReader.cs      |   4 +-
 .../BlockTerms/VariableGapTermsIndexWriter.cs      |   4 +-
 .../Bloom/BloomFilteringPostingsFormat.cs          |   3 +-
 src/Lucene.Net.Codecs/Bloom/FuzzySet.cs            |   3 +-
 .../IntBlock/FixedIntBlockIndexInput.cs            |   5 +-
 .../IntBlock/FixedIntBlockIndexOutput.cs           |   4 +-
 .../IntBlock/VariableIntBlockIndexInput.cs         |   3 +-
 .../IntBlock/VariableIntBlockIndexOutput.cs        |   9 +-
 .../Memory/DirectDocValuesConsumer.cs              |   5 +-
 .../Memory/DirectDocValuesProducer.cs              |   3 +-
 .../Memory/DirectPostingsFormat.cs                 |  63 +++---
 src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs  |  13 +-
 src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs     |   9 +-
 src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs     |  11 +-
 .../Memory/MemoryDocValuesConsumer.cs              |   5 +-
 .../Memory/MemoryDocValuesProducer.cs              |   3 +-
 .../Memory/MemoryPostingsFormat.cs                 |  27 +--
 .../Pulsing/PulsingPostingsFormat.cs               |   3 +-
 .../Pulsing/PulsingPostingsReader.cs               |  11 +-
 .../Pulsing/PulsingPostingsWriter.cs               |  21 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs     |  13 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs     |  14 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs     |   5 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs     |   5 +-
 .../SimpleText/SimpleTextDocValuesReader.cs        |  58 +++---
 .../SimpleText/SimpleTextDocValuesWriter.cs        |  55 +++--
 .../SimpleText/SimpleTextFieldInfosReader.cs       |  31 +--
 .../SimpleText/SimpleTextFieldInfosWriter.cs       |   5 +-
 .../SimpleText/SimpleTextFieldsReader.cs           |  17 +-
 .../SimpleText/SimpleTextFieldsWriter.cs           |  14 +-
 .../SimpleText/SimpleTextLiveDocsFormat.cs         |   9 +-
 .../SimpleText/SimpleTextSegmentInfoReader.cs      |  19 +-
 .../SimpleText/SimpleTextStoredFieldsReader.cs     |  17 +-
 .../SimpleText/SimpleTextTermVectorsReader.cs      |  45 +++--
 .../SimpleText/SimpleTextTermVectorsWriter.cs      |   7 +-
 src/Lucene.Net.Expressions/ExpressionComparator.cs |   5 +-
 src/Lucene.Net.Expressions/ScoreFunctionValues.cs  |   3 +-
 src/Lucene.Net.Facet/DrillDownQuery.cs             |   5 +-
 src/Lucene.Net.Facet/DrillSideways.cs              |   3 +-
 src/Lucene.Net.Facet/DrillSidewaysScorer.cs        |   8 +-
 src/Lucene.Net.Facet/FacetsConfig.cs               |   5 +-
 src/Lucene.Net.Facet/Range/LongRangeCounter.cs     |  13 +-
 src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs      |   5 +-
 .../Taxonomy/Directory/DirectoryTaxonomyWriter.cs  |   7 +-
 .../Taxonomy/Directory/TaxonomyIndexArrays.cs      |   5 +-
 src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs        |   3 +-
 .../Taxonomy/FloatTaxonomyFacets.cs                |   5 +-
 src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs    |   3 +-
 .../AbstractFirstPassGroupingCollector.cs          |  13 +-
 src/Lucene.Net.Grouping/BlockGroupingCollector.cs  |  14 +-
 src/Lucene.Net.Grouping/SearchGroup.cs             |  17 +-
 .../Term/TermGroupFacetCollector.cs                |   7 +-
 .../PostingsHighlight/MultiTermHighlighting.cs     |   5 +-
 .../PostingsHighlight/Passage.cs                   |   5 +-
 .../PostingsHighlight/PostingsHighlighter.cs       |  17 +-
 .../VectorHighlight/BaseFragListBuilder.cs         |   5 +-
 .../VectorHighlight/FieldTermStack.cs              |   5 +-
 src/Lucene.Net.Join/ToChildBlockJoinQuery.cs       |  13 +-
 src/Lucene.Net.Join/ToParentBlockJoinCollector.cs  |   7 +-
 src/Lucene.Net.Join/ToParentBlockJoinQuery.cs      |   7 +-
 .../MemoryIndex.MemoryIndexReader.cs               |  14 +-
 src/Lucene.Net.Memory/MemoryIndex.cs               |  21 +-
 src/Lucene.Net.Misc/Document/LazyDocument.cs       |  12 +-
 .../Index/MultiPassIndexSplitter.cs                |   3 +-
 src/Lucene.Net.Misc/Index/PKIndexSplitter.cs       |   5 +-
 src/Lucene.Net.Misc/Index/Sorter/Sorter.cs         |  10 +-
 .../Index/Sorter/SortingAtomicReader.cs            |   5 +-
 .../Index/Sorter/SortingMergePolicy.cs             |   4 +-
 src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs      |   7 +-
 .../Util/Fst/UpToTwoPositiveIntOutputs.cs          |  54 +++--
 src/Lucene.Net.Queries/BooleanFilter.cs            |   5 +-
 src/Lucene.Net.Queries/CommonTermsQuery.cs         |   3 +-
 .../Processors/AnalyzerQueryNodeProcessor.cs       |  11 +-
 .../Simple/SimpleQueryParser.cs                    |   5 +-
 .../IndexAndTaxonomyRevision.cs                    |   3 +-
 src/Lucene.Net.Replicator/IndexRevision.cs         |   3 +-
 src/Lucene.Net.Replicator/ReplicationClient.cs     |   5 +-
 .../Queries/SortedSetSortField.cs                  |   5 +-
 .../Prefix/AbstractPrefixTreeFilter.cs             |   3 +-
 .../Prefix/AbstractVisitingPrefixTreeFilter.cs     |  19 +-
 .../Prefix/ContainsPrefixTreeFilter.cs             |  16 +-
 src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs         |   5 +-
 .../Prefix/Tree/QuadPrefixTree.cs                  |   5 +-
 .../Prefix/Tree/SpatialPrefixTree.cs               |   5 +-
 .../Prefix/WithinPrefixTreeFilter.cs               |   8 +-
 .../Vector/DistanceValueSource.cs                  |   5 +-
 .../Suggest/Analyzing/AnalyzingSuggester.cs        |  24 ++-
 .../Suggest/Analyzing/BlendedInfixSuggester.cs     |   3 +-
 .../Suggest/Analyzing/FSTUtil.cs                   |  11 +-
 .../Suggest/Analyzing/FreeTextSuggester.cs         |  15 +-
 .../Suggest/Analyzing/SuggestStopFilter.cs         |   3 +-
 .../Suggest/Fst/FSTCompletion.cs                   |   5 +-
 .../Suggest/Fst/WFSTCompletionLookup.cs            |  11 +-
 .../Suggest/UnsortedInputIterator.cs               |   9 +-
 .../Analysis/LookaheadTokenFilter.cs               |  24 +--
 .../Analysis/MockCharFilter.cs                     |   4 +-
 .../Analysis/MockReaderWrapper.cs                  |   8 +-
 .../Analysis/MockTokenizer.cs                      |  22 +-
 .../Codecs/Asserting/AssertingDocValuesFormat.cs   |  84 ++++----
 .../Codecs/Asserting/AssertingNormsFormat.cs       |   8 +-
 .../Codecs/Asserting/AssertingPostingsFormat.cs    |  70 +++----
 .../Asserting/AssertingStoredFieldsFormat.cs       |  22 +-
 .../Codecs/Asserting/AssertingTermVectorsFormat.cs |  48 ++---
 .../Compressing/Dummy/DummyCompressingCodec.cs     |   4 +-
 .../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs   |   6 +-
 .../Codecs/Lucene3x/PreFlexRWFieldsWriter.cs       |  12 +-
 .../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs      |   4 +-
 .../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs |   6 +-
 .../Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs  |   8 +-
 .../Codecs/Lucene3x/TermInfosWriter.cs             |  14 +-
 .../Codecs/Lucene40/Lucene40DocValuesWriter.cs     |  18 +-
 .../Codecs/Lucene40/Lucene40FieldInfosWriter.cs    |  10 +-
 .../Codecs/Lucene40/Lucene40PostingsWriter.cs      |  18 +-
 .../Codecs/Lucene40/Lucene40SkipListWriter.cs      |  10 +-
 .../Codecs/Lucene42/Lucene42DocValuesConsumer.cs   |   4 +-
 .../Codecs/Lucene42/Lucene42FieldInfosWriter.cs    |   6 +-
 .../MockVariableIntBlockPostingsFormat.cs          |   4 +-
 .../Codecs/MockRandom/MockRandomPostingsFormat.cs  |   4 +-
 .../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs        |  12 +-
 .../Index/AllDeletedFilterReader.cs                |   4 +-
 .../Index/AssertingAtomicReader.cs                 | 224 ++++++++++-----------
 .../Index/BaseDocValuesFormatTestCase.cs           |  66 +++---
 .../Index/BasePostingsFormatTestCase.cs            |   4 +-
 .../Index/MockRandomMergePolicy.cs                 |   4 +-
 src/Lucene.Net.TestFramework/Index/RandomCodec.cs  |   6 +-
 .../Index/RandomDocumentsWriterPerThreadPool.cs    |  12 +-
 .../Index/RandomIndexWriter.cs                     |   4 +-
 .../Index/ThreadedIndexingAndSearchingTestCase.cs  |   6 +-
 .../Search/AssertingBulkScorer.cs                  |   4 +-
 .../Search/AssertingCollector.cs                   |   4 +-
 .../Search/AssertingScorer.cs                      |  10 +-
 src/Lucene.Net.TestFramework/Search/QueryUtils.cs  |   6 +-
 .../Search/RandomSimilarityProvider.cs             |   4 +-
 .../Search/ShardSearchingTestBase.cs               |  22 +-
 .../Store/MockDirectoryWrapper.cs                  |  12 +-
 .../Support/Diagnostics/Debug.cs                   |  46 -----
 .../Support/JavaCompatibility/LuceneTestCase.cs    |   7 +-
 .../Util/Automaton/AutomatonTestUtil.cs            |   6 +-
 .../Util/BaseDocIdSetTestCase.cs                   |   4 +-
 .../Util/FailOnNonBulkMergesInfoStream.cs          |   4 +-
 src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs |  10 +-
 .../Util/LuceneTestCase.cs                         |  16 +-
 .../Util/NullInfoStream.cs                         |   8 +-
 .../Util/TestRuleAssertionsRequired.cs             |   2 +-
 .../Util/TestRuleSetupAndRestoreClassEnv.cs        |  16 +-
 .../Util/ThrottledIndexOutput.cs                   |   4 +-
 .../Analysis/CharFilters/TestMappingCharFilter.cs  |   6 +-
 .../Analysis/Core/TestFactories.cs                 |   4 +-
 .../Analysis/Core/TestRandomChains.cs              |   6 +-
 .../Analysis/Hunspell/TestAllDictionaries.cs       |  16 +-
 .../Analysis/Hunspell/TestAllDictionaries2.cs      |  16 +-
 .../Analysis/Synonym/TestSynonymMapFilter.cs       |   6 +-
 src/Lucene.Net.Tests.Facet/FacetTestCase.cs        |   6 +-
 .../Range/TestRangeFacetCounts.cs                  |  58 +++---
 .../Taxonomy/TestTaxonomyFacetSumValueSource.cs    |   6 +-
 src/Lucene.Net.Tests.Facet/TestDrillSideways.cs    |   8 +-
 .../GroupFacetCollectorTest.cs                     |   6 +-
 .../PostingsHighlight/TestPostingsHighlighter.cs   |   7 +-
 src/Lucene.Net.Tests.Join/TestJoinUtil.cs          |   4 +-
 .../Classic/TestQueryParser.cs                     |  18 +-
 .../Flexible/Standard/TestStandardQP.cs            |  12 +-
 .../IndexAndTaxonomyReplicationClientTest.cs       |   4 +-
 .../IndexReplicationClientTest.cs                  |   4 +-
 src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs    |   8 +-
 .../Suggest/Analyzing/AnalyzingSuggesterTest.cs    |   4 +-
 .../Suggest/Analyzing/FuzzySuggesterTest.cs        |   6 +-
 .../Suggest/Analyzing/TestFreeTextSuggester.cs     |   6 +-
 .../Suggest/LookupBenchmarkTest.cs                 |   6 +-
 .../Analysis/TestGraphTokenizers.cs                |   4 +-
 .../Codecs/Lucene41/TestBlockPostingsFormat3.cs    |   4 +-
 .../Codecs/PerField/TestPerFieldDocValuesFormat.cs |   4 +-
 .../Index/TestBackwardsCompatibility.cs            |   4 +-
 .../Index/TestBackwardsCompatibility3x.cs          |   4 +-
 src/Lucene.Net.Tests/Index/TestCodecs.cs           |   8 +-
 .../Index/TestFlushByRamOrCountsPolicy.cs          |  19 +-
 src/Lucene.Net.Tests/Index/TestIndexWriter.cs      |   7 +-
 .../Index/TestIndexWriterExceptions.cs             |  26 ++-
 .../Index/TestIndexWriterMerging.cs                |   4 +-
 src/Lucene.Net.Tests/Index/TestIndexableField.cs   |   6 +-
 src/Lucene.Net.Tests/Index/TestLongPostings.cs     |   6 +-
 src/Lucene.Net.Tests/Index/TestNRTThreads.cs       |   4 +-
 src/Lucene.Net.Tests/Index/TestPayloads.cs         |   4 +-
 .../Index/TestPayloadsOnVectors.cs                 |   6 +-
 src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs  |  10 +-
 src/Lucene.Net.Tests/Index/TestStressIndexing2.cs  |   6 +-
 src/Lucene.Net.Tests/Index/TestStressNRT.cs        |   6 +-
 src/Lucene.Net.Tests/Index/TestTermsEnum.cs        |   6 +-
 .../Search/Spans/MultiSpansWrapper.cs              |   4 +-
 src/Lucene.Net.Tests/Search/TestBooleanScorer.cs   |   4 +-
 .../Search/TestConstantScoreQuery.cs               |   4 +-
 src/Lucene.Net.Tests/Search/TestFieldCache.cs      |  48 +++--
 src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs |  16 +-
 .../Search/TestMultiThreadTermVectors.cs           |   4 +-
 .../Search/TestNumericRangeQuery32.cs              |   8 +-
 .../Search/TestNumericRangeQuery64.cs              |   6 +-
 .../Search/TestTimeLimitingCollector.cs            |   4 +-
 .../Util/Automaton/TestUTF32ToUTF8.cs              |   8 +-
 src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs          |   4 +-
 .../Util/Packed/TestEliasFanoDocIdSet.cs           |   4 +-
 .../Util/Packed/TestEliasFanoSequence.cs           |   8 +-
 src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs      |   4 +-
 src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs      |   4 +-
 src/Lucene.Net/Analysis/NumericTokenStream.cs      |   3 +-
 src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs  |   5 +-
 src/Lucene.Net/Analysis/Tokenizer.cs               |   4 +-
 src/Lucene.Net/Codecs/BlockTermState.cs            |   4 +-
 src/Lucene.Net/Codecs/BlockTreeTermsReader.cs      | 182 +++++++++--------
 src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs      |  84 ++++----
 src/Lucene.Net/Codecs/CodecUtil.cs                 |   3 +-
 .../CompressingStoredFieldsIndexWriter.cs          |   9 +-
 .../Compressing/CompressingStoredFieldsReader.cs   |  22 +-
 .../Compressing/CompressingStoredFieldsWriter.cs   |  20 +-
 .../Compressing/CompressingTermVectorsReader.cs    |  21 +-
 .../Compressing/CompressingTermVectorsWriter.cs    |  45 +++--
 .../Codecs/Compressing/CompressionMode.cs          |   9 +-
 src/Lucene.Net/Codecs/Compressing/LZ4.cs           |  19 +-
 src/Lucene.Net/Codecs/DocValuesConsumer.cs         |   5 +-
 src/Lucene.Net/Codecs/FieldsConsumer.cs            |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs   |  47 +++--
 .../Codecs/Lucene3x/Lucene3xNormsProducer.cs       |   7 +-
 .../Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs   |   7 +-
 .../Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs  |   5 +-
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs   |  23 ++-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs  |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs  |   8 +-
 .../Codecs/Lucene3x/SegmentTermPositions.cs        |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs       |   9 +-
 src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs  |  15 +-
 src/Lucene.Net/Codecs/Lucene40/BitVector.cs        |  30 ++-
 .../Codecs/Lucene40/Lucene40LiveDocsFormat.cs      |  17 +-
 .../Codecs/Lucene40/Lucene40PostingsFormat.cs      |   3 +-
 .../Codecs/Lucene40/Lucene40PostingsReader.cs      |  46 +++--
 .../Codecs/Lucene40/Lucene40StoredFieldsReader.cs  |  12 +-
 .../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs  |  14 +-
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs   |  33 +--
 .../Codecs/Lucene40/Lucene40TermVectorsWriter.cs   |  28 ++-
 src/Lucene.Net/Codecs/Lucene41/ForUtil.cs          |  26 ++-
 .../Codecs/Lucene41/Lucene41PostingsFormat.cs      |   6 +-
 .../Codecs/Lucene41/Lucene41PostingsReader.cs      |  23 ++-
 .../Codecs/Lucene41/Lucene41PostingsWriter.cs      |  16 +-
 .../Codecs/Lucene41/Lucene41SkipReader.cs          |   3 +-
 .../Codecs/Lucene42/Lucene42NormsConsumer.cs       |   5 +-
 .../Codecs/Lucene45/Lucene45DocValuesConsumer.cs   |   5 +-
 .../Codecs/Lucene46/Lucene46FieldInfosWriter.cs    |   5 +-
 src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs      |   3 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs  |   3 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs  |   3 +-
 .../Codecs/PerField/PerFieldDocValuesFormat.cs     |  11 +-
 .../Codecs/PerField/PerFieldPostingsFormat.cs      |   9 +-
 src/Lucene.Net/Codecs/PostingsConsumer.cs          |   3 +-
 src/Lucene.Net/Codecs/TermVectorsWriter.cs         |  20 +-
 src/Lucene.Net/Codecs/TermsConsumer.cs             |  11 +-
 src/Lucene.Net/Index/AtomicReader.cs               |  12 +-
 src/Lucene.Net/Index/AtomicReaderContext.cs        |   3 +-
 src/Lucene.Net/Index/AutomatonTermsEnum.cs         |   9 +-
 src/Lucene.Net/Index/BitsSlice.cs                  |   5 +-
 src/Lucene.Net/Index/BufferedUpdatesStream.cs      |  58 +++---
 src/Lucene.Net/Index/ByteSliceReader.cs            |  23 ++-
 src/Lucene.Net/Index/ByteSliceWriter.cs            |  13 +-
 src/Lucene.Net/Index/CheckIndex.cs                 |  67 +++---
 src/Lucene.Net/Index/CompositeReader.cs            |   5 +-
 src/Lucene.Net/Index/CompositeReaderContext.cs     |   5 +-
 src/Lucene.Net/Index/ConcurrentMergeScheduler.cs   |   3 +-
 src/Lucene.Net/Index/DirectoryReader.cs            |   8 +-
 src/Lucene.Net/Index/DocFieldProcessor.cs          |  10 +-
 src/Lucene.Net/Index/DocTermOrds.cs                |  24 +--
 src/Lucene.Net/Index/DocValuesFieldUpdates.cs      |   5 +-
 src/Lucene.Net/Index/DocValuesProcessor.cs         |   5 +-
 src/Lucene.Net/Index/DocumentsWriter.cs            |  56 +++---
 src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs |   8 +-
 .../Index/DocumentsWriterFlushControl.cs           |  98 +++++----
 src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs  |  46 +++--
 src/Lucene.Net/Index/DocumentsWriterPerThread.cs   |  42 ++--
 .../Index/DocumentsWriterPerThreadPool.cs          |  67 ++++--
 .../Index/DocumentsWriterStallControl.cs           |  18 +-
 src/Lucene.Net/Index/FieldInfo.cs                  |  32 +--
 src/Lucene.Net/Index/FieldInfos.cs                 |  14 +-
 src/Lucene.Net/Index/FilteredTermsEnum.cs          |   7 +-
 src/Lucene.Net/Index/FlushPolicy.cs                |   9 +-
 src/Lucene.Net/Index/FreqProxTermsWriter.cs        |   4 +-
 .../Index/FreqProxTermsWriterPerField.cs           |  57 +++---
 src/Lucene.Net/Index/FrozenBufferedUpdates.cs      |   8 +-
 src/Lucene.Net/Index/IndexFileDeleter.cs           |  47 +++--
 src/Lucene.Net/Index/IndexFileNames.cs             |   6 +-
 src/Lucene.Net/Index/IndexFormatTooNewException.cs |   4 +-
 src/Lucene.Net/Index/IndexFormatTooOldException.cs |   6 +-
 src/Lucene.Net/Index/IndexWriter.cs                | 199 +++++++++---------
 src/Lucene.Net/Index/LogMergePolicy.cs             |  10 +-
 src/Lucene.Net/Index/MergePolicy.cs                |  10 +-
 src/Lucene.Net/Index/MergeState.cs                 |   8 +-
 src/Lucene.Net/Index/MultiBits.cs                  |  17 +-
 src/Lucene.Net/Index/MultiDocValues.cs             |  20 +-
 src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs  |   6 +-
 src/Lucene.Net/Index/MultiDocsEnum.cs              |   4 +-
 src/Lucene.Net/Index/MultiFields.cs                |  20 +-
 src/Lucene.Net/Index/MultiTerms.cs                 |   4 +-
 src/Lucene.Net/Index/MultiTermsEnum.cs             |  24 +--
 src/Lucene.Net/Index/NormsConsumer.cs              |   8 +-
 .../Index/NumericDocValuesFieldUpdates.cs          |   4 +-
 src/Lucene.Net/Index/OrdTermState.cs               |   4 +-
 src/Lucene.Net/Index/ParallelCompositeReader.cs    |   4 +-
 src/Lucene.Net/Index/PrefixCodedTerms.cs           |   7 +-
 src/Lucene.Net/Index/ReadersAndUpdates.cs          |  59 +++---
 src/Lucene.Net/Index/SegmentCoreReaders.cs         |   8 +-
 src/Lucene.Net/Index/SegmentDocValues.cs           |   6 +-
 src/Lucene.Net/Index/SegmentInfo.cs                |   6 +-
 src/Lucene.Net/Index/SegmentInfos.cs               |  14 +-
 src/Lucene.Net/Index/SegmentMerger.cs              |   8 +-
 src/Lucene.Net/Index/SegmentReader.cs              |  14 +-
 src/Lucene.Net/Index/SimpleMergedSegmentWarmer.cs  |   4 +-
 .../Index/SingletonSortedSetDocValues.cs           |   4 +-
 src/Lucene.Net/Index/SlowCompositeReaderWrapper.cs |   6 +-
 src/Lucene.Net/Index/SnapshotDeletionPolicy.cs     |   4 +-
 src/Lucene.Net/Index/SortedDocValuesTermsEnum.cs   |   8 +-
 src/Lucene.Net/Index/SortedDocValuesWriter.cs      |   5 +-
 .../Index/SortedSetDocValuesTermsEnum.cs           |   8 +-
 src/Lucene.Net/Index/SortedSetDocValuesWriter.cs   |   6 +-
 src/Lucene.Net/Index/StandardDirectoryReader.cs    |  11 +-
 src/Lucene.Net/Index/StoredFieldsProcessor.cs      |  11 +-
 src/Lucene.Net/Index/TermContext.cs                |  17 +-
 src/Lucene.Net/Index/TermVectorsConsumer.cs        |  16 +-
 .../Index/TermVectorsConsumerPerField.cs           |  19 +-
 src/Lucene.Net/Index/TermsHashPerField.cs          |   8 +-
 .../ThreadAffinityDocumentsWriterThreadPool.cs     |  11 +-
 src/Lucene.Net/Lucene.Net.csproj                   |   1 +
 src/Lucene.Net/Search/CachingWrapperFilter.cs      |   4 +-
 src/Lucene.Net/Search/CollectionStatistics.cs      |  13 +-
 src/Lucene.Net/Search/ConstantScoreAutoRewrite.cs  |   8 +-
 src/Lucene.Net/Search/ConstantScoreQuery.cs        |  14 +-
 src/Lucene.Net/Search/DisjunctionScorer.cs         |   6 +-
 src/Lucene.Net/Search/DocIdSetIterator.cs          |  13 +-
 src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs    |   6 +-
 src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs  |   6 +-
 src/Lucene.Net/Search/ExactPhraseScorer.cs         |   4 +-
 src/Lucene.Net/Search/FieldCacheImpl.cs            |  14 +-
 src/Lucene.Net/Search/FieldCacheRangeFilter.cs     |   9 +-
 src/Lucene.Net/Search/FieldCacheRewriteMethod.cs   |   6 +-
 src/Lucene.Net/Search/FieldComparator.cs           |  18 +-
 src/Lucene.Net/Search/FieldValueHitQueue.cs        |  16 +-
 src/Lucene.Net/Search/FilteredQuery.cs             |  10 +-
 src/Lucene.Net/Search/FuzzyTermsEnum.cs            |   6 +-
 src/Lucene.Net/Search/IndexSearcher.cs             |   8 +-
 src/Lucene.Net/Search/MinShouldMatchSumScorer.cs   |   6 +-
 src/Lucene.Net/Search/MultiPhraseQuery.cs          |  12 +-
 .../Search/MultiTermQueryWrapperFilter.cs          |   6 +-
 src/Lucene.Net/Search/NumericRangeQuery.cs         |  16 +-
 src/Lucene.Net/Search/PhraseQuery.cs               |   8 +-
 src/Lucene.Net/Search/QueryRescorer.cs             |   4 +-
 src/Lucene.Net/Search/ReferenceManager.cs          |   8 +-
 src/Lucene.Net/Search/ReqOptSumScorer.cs           |   9 +-
 src/Lucene.Net/Search/ScoringRewrite.cs            |  12 +-
 src/Lucene.Net/Search/SearcherManager.cs           |   6 +-
 .../Search/Similarities/SimilarityBase.cs          |   4 +-
 src/Lucene.Net/Search/SloppyPhraseScorer.cs        |   6 +-
 src/Lucene.Net/Search/SortField.cs                 |   4 +-
 src/Lucene.Net/Search/SortRescorer.cs              |   4 +-
 src/Lucene.Net/Search/Spans/NearSpansOrdered.cs    |   8 +-
 src/Lucene.Net/Search/Spans/SpanFirstQuery.cs      |   4 +-
 .../Search/Spans/SpanPositionRangeQuery.cs         |   4 +-
 src/Lucene.Net/Search/Spans/TermSpans.cs           |   4 +-
 src/Lucene.Net/Search/TermCollectingRewrite.cs     |   4 +-
 src/Lucene.Net/Search/TermQuery.cs                 |  14 +-
 src/Lucene.Net/Search/TermScorer.cs                |   4 +-
 src/Lucene.Net/Search/TermStatistics.cs            |   9 +-
 src/Lucene.Net/Search/TopDocs.cs                   |  12 +-
 src/Lucene.Net/Search/TopScoreDocCollector.cs      |  22 +-
 src/Lucene.Net/Search/TopTermsRewrite.cs           |  20 +-
 src/Lucene.Net/Store/BaseDirectory.cs              |   5 +-
 src/Lucene.Net/Store/BufferedIndexInput.cs         |   4 +-
 src/Lucene.Net/Store/ByteArrayDataOutput.cs        |   7 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs       |  15 +-
 src/Lucene.Net/Store/CompoundFileDirectory.cs      |  10 +-
 src/Lucene.Net/Store/CompoundFileWriter.cs         |  20 +-
 src/Lucene.Net/Store/DataInput.cs                  |   4 +-
 src/Lucene.Net/Store/DataOutput.cs                 |   6 +-
 src/Lucene.Net/Store/IOContext.cs                  |  11 +-
 src/Lucene.Net/Store/IndexInput.cs                 |   2 +-
 src/Lucene.Net/Store/IndexOutput.cs                |   2 +-
 src/Lucene.Net/Store/MMapDirectory.cs              |   5 +-
 src/Lucene.Net/Store/NIOFSDirectory.cs             |  19 +-
 src/Lucene.Net/Store/RAMOutputStream.cs            |   4 +-
 .../Store/RateLimitedDirectoryWrapper.cs           |   2 +-
 src/Lucene.Net/Store/SimpleFSDirectory.cs          |   6 +-
 src/Lucene.Net/Support/BitArrayExtensions.cs       |   2 +-
 src/Lucene.Net/Support/Collections.cs              |   4 +-
 .../Support/Diagnostics/AssertionException.cs      |   0
 src/Lucene.Net/Support/Diagnostics/Debugging.cs    |  60 +++++-
 src/Lucene.Net/Util/ArrayUtil.cs                   |  43 ++--
 src/Lucene.Net/Util/AttributeSource.cs             |   5 +-
 src/Lucene.Net/Util/Automaton/Automaton.cs         |   6 +-
 src/Lucene.Net/Util/Automaton/BasicOperations.cs   |  10 +-
 src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs |  10 +-
 .../Util/Automaton/DaciukMihovAutomatonBuilder.cs  |  23 ++-
 .../Util/Automaton/Lev1ParametricDescription.cs    |   6 +-
 .../Util/Automaton/Lev1TParametricDescription.cs   |   6 +-
 .../Util/Automaton/Lev2ParametricDescription.cs    |   6 +-
 .../Util/Automaton/Lev2TParametricDescription.cs   |   6 +-
 .../Util/Automaton/LevenshteinAutomata.cs          |   4 +-
 src/Lucene.Net/Util/Automaton/SortedIntSet.cs      |   4 +-
 src/Lucene.Net/Util/Automaton/State.cs             |   4 +-
 src/Lucene.Net/Util/Automaton/Transition.cs        |  12 +-
 src/Lucene.Net/Util/Automaton/UTF32ToUTF8.cs       |   9 +-
 src/Lucene.Net/Util/BroadWord.cs                   |   7 +-
 src/Lucene.Net/Util/ByteBlockPool.cs               |   4 +-
 src/Lucene.Net/Util/BytesRef.cs                    |  14 +-
 src/Lucene.Net/Util/BytesRefArray.cs               |   4 +-
 src/Lucene.Net/Util/BytesRefHash.cs                |  46 +++--
 src/Lucene.Net/Util/CharsRef.cs                    |   6 +-
 src/Lucene.Net/Util/FilterIterator.cs              |   4 +-
 src/Lucene.Net/Util/FixedBitSet.cs                 |  41 ++--
 src/Lucene.Net/Util/Fst/Builder.cs                 |  58 +++---
 src/Lucene.Net/Util/Fst/ByteSequenceOutputs.cs     |  36 ++--
 src/Lucene.Net/Util/Fst/BytesRefFSTEnum.cs         |   4 +-
 src/Lucene.Net/Util/Fst/BytesStore.cs              |  26 ++-
 src/Lucene.Net/Util/Fst/CharSequenceOutputs.cs     |  39 ++--
 src/Lucene.Net/Util/Fst/FST.cs                     |  89 ++++----
 src/Lucene.Net/Util/Fst/FSTEnum.cs                 |  31 ++-
 src/Lucene.Net/Util/Fst/IntSequenceOutputs.cs      |  39 ++--
 src/Lucene.Net/Util/Fst/IntsRefFSTEnum.cs          |   4 +-
 src/Lucene.Net/Util/Fst/NoOutputs.cs               |  30 ++-
 src/Lucene.Net/Util/Fst/NodeHash.cs                |   6 +-
 src/Lucene.Net/Util/Fst/PairOutputs.cs             |  29 ++-
 src/Lucene.Net/Util/Fst/PositiveIntOutputs.cs      |  38 ++--
 src/Lucene.Net/Util/Fst/Util.cs                    |  14 +-
 src/Lucene.Net/Util/IndexableBinaryStringTools.cs  |   6 +-
 src/Lucene.Net/Util/InfoStream.cs                  |   4 +-
 src/Lucene.Net/Util/IntBlockPool.cs                |  19 +-
 src/Lucene.Net/Util/IntsRef.cs                     |   6 +-
 src/Lucene.Net/Util/LongBitSet.cs                  |  41 ++--
 src/Lucene.Net/Util/LongsRef.cs                    |   6 +-
 src/Lucene.Net/Util/MergedIterator.cs              |   4 +-
 src/Lucene.Net/Util/OfflineSorter.cs               |  16 +-
 src/Lucene.Net/Util/OpenBitSet.cs                  |  36 ++--
 src/Lucene.Net/Util/PForDeltaDocIdSet.cs           |  36 ++--
 .../Util/Packed/AbstractAppendingLongBuffer.cs     |  15 +-
 .../Util/Packed/AbstractBlockPackedWriter.cs       |   4 +-
 src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs |   8 +-
 src/Lucene.Net/Util/Packed/BlockPackedReader.cs    |   4 +-
 .../Util/Packed/BlockPackedReaderIterator.cs       |  14 +-
 src/Lucene.Net/Util/Packed/BlockPackedWriter.cs    |   4 +-
 src/Lucene.Net/Util/Packed/BulkOperation.cs        |   6 +-
 src/Lucene.Net/Util/Packed/BulkOperationPacked.cs  |  18 +-
 src/Lucene.Net/Util/Packed/Direct16.cs             |  22 +-
 src/Lucene.Net/Util/Packed/Direct32.cs             |  22 +-
 src/Lucene.Net/Util/Packed/Direct64.cs             |  20 +-
 src/Lucene.Net/Util/Packed/Direct8.cs              |  22 +-
 src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs     |  30 +--
 src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs     |   7 +-
 src/Lucene.Net/Util/Packed/GrowableWriter.cs       |   4 +-
 .../Util/Packed/MonotonicAppendingLongBuffer.cs    |   4 +-
 .../Util/Packed/MonotonicBlockPackedReader.cs      |   4 +-
 .../Util/Packed/MonotonicBlockPackedWriter.cs      |   6 +-
 src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs  |  20 +-
 src/Lucene.Net/Util/Packed/Packed64.cs             |  49 ++---
 src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs  |  54 +++--
 src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs   |  20 +-
 src/Lucene.Net/Util/Packed/PackedDataInput.cs      |   5 +-
 src/Lucene.Net/Util/Packed/PackedDataOutput.cs     |   4 +-
 src/Lucene.Net/Util/Packed/PackedInts.cs           |  93 +++++----
 src/Lucene.Net/Util/Packed/PackedReaderIterator.cs |  13 +-
 src/Lucene.Net/Util/Packed/PackedWriter.cs         |  12 +-
 src/Lucene.Net/Util/Packed/PagedMutable.cs         |   4 +-
 src/Lucene.Net/Util/PagedBytes.cs                  |  20 +-
 src/Lucene.Net/Util/QueryBuilder.cs                |  14 +-
 src/Lucene.Net/Util/RamUsageEstimator.cs           |  24 ++-
 src/Lucene.Net/Util/RecyclingByteBlockAllocator.cs |   8 +-
 src/Lucene.Net/Util/RecyclingIntBlockAllocator.cs  |   8 +-
 src/Lucene.Net/Util/RollingBuffer.cs               |  13 +-
 src/Lucene.Net/Util/SentinelIntSet.cs              |   6 +-
 src/Lucene.Net/Util/Sorter.cs                      |   4 +-
 src/Lucene.Net/Util/TimSorter.cs                   |  22 +-
 src/Lucene.Net/Util/UnicodeUtil.cs                 |   6 +-
 src/Lucene.Net/Util/WAH8DocIdSet.cs                |  76 ++++---
 .../TestICUPostingsHighlighter.cs                  |  11 +-
 515 files changed, 4070 insertions(+), 3281 deletions(-)
 delete mode 100644 src/Lucene.Net.TestFramework/Support/Diagnostics/Debug.cs
 rename src/{Lucene.Net.TestFramework => Lucene.Net}/Support/Diagnostics/AssertionException.cs (100%)


[lucenenet] 12/13: Lucene.Net.Tests: Don't run tests that require asserts unless asserts are enabled. (closes #326, see #313)

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 4b31e7cdf3a084a229980d53ac30e8ff89743a60
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Sat Aug 22 15:26:32 2020 +0700

    Lucene.Net.Tests: Don't run tests that require asserts unless asserts are enabled. (closes #326, see #313)
---
 .../Index/TestFlushByRamOrCountsPolicy.cs          | 15 +++++++++++++
 .../Index/TestIndexWriterExceptions.cs             | 26 +++++++++++++---------
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs b/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
index 4bdfe89..58bd570 100644
--- a/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
+++ b/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
@@ -1,5 +1,6 @@
 using J2N.Threading;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Store;
 using NUnit.Framework;
@@ -62,6 +63,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestFlushByRam()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             double ramBuffer = (TestNightly ? 1 : 10) + AtLeast(2) + Random.NextDouble();
             RunFlushByRam(1 + Random.Next(TestNightly ? 5 : 1), ramBuffer, false);
         }
@@ -69,6 +73,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestFlushByRamLargeBuffer()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             // with a 256 mb ram buffer we should never stall
             RunFlushByRam(1 + Random.Next(TestNightly ? 5 : 1), 256d, true);
         }
@@ -132,6 +139,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestFlushDocCount()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             int[] numThreads = new int[] { 2 + AtLeast(1), 1 };
             for (int i = 0; i < numThreads.Length; i++)
             {
@@ -184,6 +194,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestRandom()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             int numThreads = 1 + Random.Next(8);
             int numDocumentsToIndex = 50 + AtLeast(70);
             AtomicInt32 numDocs = new AtomicInt32(numDocumentsToIndex);
@@ -247,6 +260,8 @@ namespace Lucene.Net.Index
         [Slow] // LUCENENET: occasionally
         public virtual void TestStallControl()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
 
             int[] numThreads = new int[] { 4 + Random.Next(8), 1 };
             int numDocumentsToIndex = 50 + Random.Next(50);
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
index e81a33d..58ce2a2 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
@@ -2,6 +2,7 @@ using J2N.Threading;
 using J2N.Threading.Atomic;
 using Lucene.Net.Analysis;
 using Lucene.Net.Attributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Store;
@@ -497,6 +498,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestExceptionDocumentsWriterInit()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             Directory dir = NewDirectory();
             TestPoint2 testPoint = new TestPoint2();
             IndexWriter w = RandomIndexWriter.MockIndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)), testPoint);
@@ -576,6 +580,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestExceptionOnMergeInit([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             Directory dir = NewDirectory();
             IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMaxBufferedDocs(2).SetMergePolicy(NewLogMergePolicy());
 
@@ -1296,23 +1303,17 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestRollbackExceptionHang()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             Directory dir = NewDirectory();
             TestPoint4 testPoint = new TestPoint4();
             IndexWriter w = RandomIndexWriter.MockIndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)), testPoint);
 
             AddDoc(w);
             testPoint.doFail = true;
-            try
-            {
-                w.Rollback();
-                Assert.Fail("did not hit intentional RuntimeException");
-            }
-#pragma warning disable 168
-            catch (Exception re)
-#pragma warning restore 168
-            {
-                // expected
-            }
+            // LUCENENET: Don't assert in try block
+            Assert.Throws<Exception>(() => w.Rollback(), "did not hit intentional RuntimeException");
 
             testPoint.doFail = false;
             w.Rollback();
@@ -2435,6 +2436,9 @@ namespace Lucene.Net.Index
         [Test]
         public virtual void TestExceptionDuringRollback()
         {
+            // LUCENENET specific - disable the test if asserts are not enabled
+            AssumeTrue("This test requires asserts to be enabled.", Debugging.AssertsEnabled);
+
             // currently: fail in two different places
             string messageToFailOn = Random.NextBoolean() ? "rollback: done finish merges" : "rollback before checkpoint";
 


[lucenenet] 07/13: Added if (Debugging.AssertsEnabled) blocks to improve performance when asserts are disabled

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 8a7f282fb3da837a5fa4487be553b825fb8cb468
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Tue Aug 18 19:31:28 2020 +0700

    Added if (Debugging.AssertsEnabled) blocks to improve performance when asserts are disabled
---
 .../Analysis/CharFilter/BaseCharFilter.cs          |   2 +-
 .../Analysis/CharFilter/HTMLStripCharFilter.cs     |  22 +-
 .../Analysis/CharFilter/MappingCharFilter.cs       |   2 +-
 .../Analysis/CharFilter/NormalizeCharMap.cs        |   2 +-
 .../Compound/CompoundWordTokenFilterBase.cs        |   2 +-
 .../Analysis/Gl/GalicianStemmer.cs                 |   2 +-
 .../Analysis/Hunspell/Dictionary.cs                |   4 +-
 .../Analysis/Hunspell/Stemmer.cs                   |   4 +-
 .../Analysis/Miscellaneous/ASCIIFoldingFilter.cs   |   2 +-
 .../Miscellaneous/SingleTokenTokenStream.cs        |   4 +-
 .../Analysis/NGram/NGramTokenizer.cs               |   4 +-
 .../Pattern/PatternCaptureGroupTokenFilter.cs      |   2 +-
 .../Analysis/Pt/PortugueseStemmer.cs               |   2 +-
 .../Analysis/Pt/RSLPStemmerBase.cs                 |   2 +-
 .../Analysis/Synonym/SynonymFilter.cs              |  18 +-
 .../Analysis/Synonym/SynonymMap.cs                 |   9 +-
 .../Analysis/Util/CharArrayMap.cs                  |   2 +-
 .../Analysis/Util/CharTokenizer.cs                 |   4 +-
 .../Analysis/Util/CharacterUtils.cs                |  32 ++-
 .../Analysis/Util/RollingCharBuffer.cs             |  27 ++-
 .../Analysis/Util/SegmentingTokenizerBase.cs       |   2 +-
 .../Analysis/Util/StemmerUtil.cs                   |   4 +-
 .../Analysis/Icu/ICUNormalizer2CharFilter.cs       |   2 +-
 .../Analysis/Icu/Segmentation/ICUTokenizer.cs      |   2 +-
 .../Icu/Segmentation/ICUTokenizerFactory.cs        |   4 +-
 .../Dict/TokenInfoFST.cs                           |   2 +-
 .../GraphvizFormatter.cs                           |   7 +-
 .../JapaneseIterationMarkCharFilter.cs             |   2 +-
 .../JapaneseTokenizer.cs                           |  39 ++--
 .../Tools/BinaryDictionaryWriter.cs                |  27 +--
 .../Tools/ConnectionCostsBuilder.cs                |   6 +-
 .../Tools/ConnectionCostsWriter.cs                 |   4 +-
 .../BeiderMorseFilter.cs                           |   2 +-
 .../ByTask/Utils/AnalyzerFactory.cs                |   2 +-
 src/Lucene.Net.Benchmark/Quality/QualityStats.cs   |   2 +-
 src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs |   2 +-
 .../BlockTerms/BlockTermsReader.cs                 |  35 ++--
 .../BlockTerms/BlockTermsWriter.cs                 |  15 +-
 .../BlockTerms/FixedGapTermsIndexReader.cs         |  27 +--
 .../BlockTerms/FixedGapTermsIndexWriter.cs         |   2 +-
 .../BlockTerms/VariableGapTermsIndexReader.cs      |   2 +-
 .../BlockTerms/VariableGapTermsIndexWriter.cs      |   2 +-
 .../Bloom/BloomFilteringPostingsFormat.cs          |   2 +-
 src/Lucene.Net.Codecs/Bloom/FuzzySet.cs            |   2 +-
 .../IntBlock/FixedIntBlockIndexInput.cs            |   4 +-
 .../IntBlock/FixedIntBlockIndexOutput.cs           |   2 +-
 .../IntBlock/VariableIntBlockIndexInput.cs         |   2 +-
 .../IntBlock/VariableIntBlockIndexOutput.cs        |   8 +-
 .../Memory/DirectDocValuesConsumer.cs              |   2 +-
 .../Memory/DirectDocValuesProducer.cs              |   2 +-
 .../Memory/DirectPostingsFormat.cs                 |  58 +++---
 src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs  |  12 +-
 src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs     |   6 +-
 src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs     |   8 +-
 .../Memory/MemoryDocValuesConsumer.cs              |   2 +-
 .../Memory/MemoryDocValuesProducer.cs              |   2 +-
 .../Memory/MemoryPostingsFormat.cs                 |  24 +--
 .../Pulsing/PulsingPostingsFormat.cs               |   2 +-
 .../Pulsing/PulsingPostingsReader.cs               |  10 +-
 .../Pulsing/PulsingPostingsWriter.cs               |  20 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs     |  10 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs     |  11 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs     |   2 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs     |   2 +-
 .../SimpleText/SimpleTextDocValuesReader.cs        |  47 +++--
 .../SimpleText/SimpleTextDocValuesWriter.cs        |  52 +++--
 .../SimpleText/SimpleTextFieldInfosReader.cs       |  28 +--
 .../SimpleText/SimpleTextFieldInfosWriter.cs       |   2 +-
 .../SimpleText/SimpleTextFieldsReader.cs           |  12 +-
 .../SimpleText/SimpleTextFieldsWriter.cs           |  11 +-
 .../SimpleText/SimpleTextLiveDocsFormat.cs         |   6 +-
 .../SimpleText/SimpleTextSegmentInfoReader.cs      |  16 +-
 .../SimpleText/SimpleTextStoredFieldsReader.cs     |  14 +-
 .../SimpleText/SimpleTextTermVectorsReader.cs      |  34 ++--
 .../SimpleText/SimpleTextTermVectorsWriter.cs      |   4 +-
 src/Lucene.Net.Expressions/ExpressionComparator.cs |   4 +-
 src/Lucene.Net.Expressions/ScoreFunctionValues.cs  |   2 +-
 src/Lucene.Net.Facet/DrillDownQuery.cs             |   2 +-
 src/Lucene.Net.Facet/DrillSideways.cs              |   2 +-
 src/Lucene.Net.Facet/DrillSidewaysScorer.cs        |   6 +-
 src/Lucene.Net.Facet/FacetsConfig.cs               |   2 +-
 src/Lucene.Net.Facet/Range/LongRangeCounter.cs     |  10 +-
 src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs      |   4 +-
 .../Taxonomy/Directory/DirectoryTaxonomyWriter.cs  |   6 +-
 .../Taxonomy/Directory/TaxonomyIndexArrays.cs      |   2 +-
 src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs        |   2 +-
 .../Taxonomy/FloatTaxonomyFacets.cs                |   2 +-
 src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs    |   2 +-
 .../AbstractFirstPassGroupingCollector.cs          |  10 +-
 src/Lucene.Net.Grouping/BlockGroupingCollector.cs  |  11 +-
 src/Lucene.Net.Grouping/SearchGroup.cs             |  14 +-
 .../Term/TermGroupFacetCollector.cs                |   4 +-
 .../PostingsHighlight/MultiTermHighlighting.cs     |   4 +-
 .../PostingsHighlight/Passage.cs                   |   4 +-
 .../PostingsHighlight/PostingsHighlighter.cs       |  16 +-
 .../VectorHighlight/BaseFragListBuilder.cs         |   2 +-
 .../VectorHighlight/FieldTermStack.cs              |   2 +-
 src/Lucene.Net.Join/ToChildBlockJoinQuery.cs       |  10 +-
 src/Lucene.Net.Join/ToParentBlockJoinCollector.cs  |   4 +-
 src/Lucene.Net.Join/ToParentBlockJoinQuery.cs      |   4 +-
 .../MemoryIndex.MemoryIndexReader.cs               |  13 +-
 src/Lucene.Net.Memory/MemoryIndex.cs               |  20 +-
 src/Lucene.Net.Misc/Document/LazyDocument.cs       |   9 +-
 .../Index/MultiPassIndexSplitter.cs                |   2 +-
 src/Lucene.Net.Misc/Index/PKIndexSplitter.cs       |   2 +-
 src/Lucene.Net.Misc/Index/Sorter/Sorter.cs         |   7 +-
 .../Index/Sorter/SortingAtomicReader.cs            |   2 +-
 .../Index/Sorter/SortingMergePolicy.cs             |   2 +-
 src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs      |   4 +-
 .../Util/Fst/UpToTwoPositiveIntOutputs.cs          |  43 ++--
 src/Lucene.Net.Queries/BooleanFilter.cs            |   2 +-
 src/Lucene.Net.Queries/CommonTermsQuery.cs         |   2 +-
 .../Processors/AnalyzerQueryNodeProcessor.cs       |  10 +-
 .../Simple/SimpleQueryParser.cs                    |   4 +-
 .../IndexAndTaxonomyRevision.cs                    |   2 +-
 src/Lucene.Net.Replicator/IndexRevision.cs         |   2 +-
 src/Lucene.Net.Replicator/ReplicationClient.cs     |   4 +-
 .../Queries/SortedSetSortField.cs                  |   2 +-
 .../Prefix/AbstractPrefixTreeFilter.cs             |   2 +-
 .../Prefix/AbstractVisitingPrefixTreeFilter.cs     |  18 +-
 .../Prefix/ContainsPrefixTreeFilter.cs             |  15 +-
 src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs         |   4 +-
 .../Prefix/Tree/QuadPrefixTree.cs                  |   4 +-
 .../Prefix/Tree/SpatialPrefixTree.cs               |   4 +-
 .../Prefix/WithinPrefixTreeFilter.cs               |   7 +-
 .../Vector/DistanceValueSource.cs                  |   2 +-
 .../Suggest/Analyzing/AnalyzingSuggester.cs        |  23 ++-
 .../Suggest/Analyzing/BlendedInfixSuggester.cs     |   2 +-
 .../Suggest/Analyzing/FSTUtil.cs                   |   8 +-
 .../Suggest/Analyzing/FreeTextSuggester.cs         |  14 +-
 .../Suggest/Analyzing/SuggestStopFilter.cs         |   2 +-
 .../Suggest/Fst/FSTCompletion.cs                   |   2 +-
 .../Suggest/Fst/WFSTCompletionLookup.cs            |   8 +-
 .../Suggest/UnsortedInputIterator.cs               |   6 +-
 .../Analysis/LookaheadTokenFilter.cs               |  22 +-
 .../Analysis/MockCharFilter.cs                     |   2 +-
 .../Analysis/MockReaderWrapper.cs                  |   6 +-
 .../Analysis/MockTokenizer.cs                      |  16 +-
 .../Codecs/Asserting/AssertingDocValuesFormat.cs   |  82 ++++----
 .../Codecs/Asserting/AssertingNormsFormat.cs       |   6 +-
 .../Codecs/Asserting/AssertingPostingsFormat.cs    |  68 +++----
 .../Asserting/AssertingStoredFieldsFormat.cs       |  20 +-
 .../Codecs/Asserting/AssertingTermVectorsFormat.cs |  46 ++---
 .../Compressing/Dummy/DummyCompressingCodec.cs     |   2 +-
 .../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs   |   4 +-
 .../Codecs/Lucene3x/PreFlexRWFieldsWriter.cs       |  10 +-
 .../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs      |   2 +-
 .../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs |   4 +-
 .../Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs  |   6 +-
 .../Codecs/Lucene3x/TermInfosWriter.cs             |  12 +-
 .../Codecs/Lucene40/Lucene40DocValuesWriter.cs     |  16 +-
 .../Codecs/Lucene40/Lucene40FieldInfosWriter.cs    |   8 +-
 .../Codecs/Lucene40/Lucene40PostingsWriter.cs      |  16 +-
 .../Codecs/Lucene40/Lucene40SkipListWriter.cs      |   8 +-
 .../Codecs/Lucene42/Lucene42DocValuesConsumer.cs   |   2 +-
 .../Codecs/Lucene42/Lucene42FieldInfosWriter.cs    |   4 +-
 .../MockVariableIntBlockPostingsFormat.cs          |   2 +-
 .../Codecs/MockRandom/MockRandomPostingsFormat.cs  |   2 +-
 .../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs        |  10 +-
 .../Index/AllDeletedFilterReader.cs                |   2 +-
 .../Index/AssertingAtomicReader.cs                 | 222 ++++++++++-----------
 .../Index/BaseDocValuesFormatTestCase.cs           |  64 +++---
 .../Index/BasePostingsFormatTestCase.cs            |   2 +-
 .../Index/MockRandomMergePolicy.cs                 |   2 +-
 src/Lucene.Net.TestFramework/Index/RandomCodec.cs  |   4 +-
 .../Index/RandomDocumentsWriterPerThreadPool.cs    |  10 +-
 .../Index/RandomIndexWriter.cs                     |   2 +-
 .../Index/ThreadedIndexingAndSearchingTestCase.cs  |   4 +-
 .../Search/AssertingBulkScorer.cs                  |   2 +-
 .../Search/AssertingCollector.cs                   |   2 +-
 .../Search/AssertingScorer.cs                      |   8 +-
 src/Lucene.Net.TestFramework/Search/QueryUtils.cs  |   4 +-
 .../Search/RandomSimilarityProvider.cs             |   2 +-
 .../Search/ShardSearchingTestBase.cs               |  20 +-
 .../Store/MockDirectoryWrapper.cs                  |   6 +-
 .../Support/JavaCompatibility/LuceneTestCase.cs    |   2 +-
 .../Util/Automaton/AutomatonTestUtil.cs            |   4 +-
 .../Util/BaseDocIdSetTestCase.cs                   |   2 +-
 .../Util/FailOnNonBulkMergesInfoStream.cs          |   2 +-
 src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs |   8 +-
 .../Util/LuceneTestCase.cs                         |  14 +-
 .../Util/NullInfoStream.cs                         |   6 +-
 .../Util/TestRuleAssertionsRequired.cs             |   2 +-
 .../Util/TestRuleSetupAndRestoreClassEnv.cs        |  14 +-
 .../Util/ThrottledIndexOutput.cs                   |   2 +-
 .../Analysis/CharFilters/TestMappingCharFilter.cs  |   2 +-
 .../Analysis/Core/TestFactories.cs                 |   2 +-
 .../Analysis/Core/TestRandomChains.cs              |   4 +-
 .../Analysis/Hunspell/TestAllDictionaries.cs       |  12 +-
 .../Analysis/Hunspell/TestAllDictionaries2.cs      |  12 +-
 .../Analysis/Synonym/TestSynonymMapFilter.cs       |   2 +-
 src/Lucene.Net.Tests.Facet/FacetTestCase.cs        |   2 +-
 .../Range/TestRangeFacetCounts.cs                  |   2 +-
 .../Taxonomy/TestTaxonomyFacetSumValueSource.cs    |   2 +-
 src/Lucene.Net.Tests.Facet/TestDrillSideways.cs    |   6 +-
 .../GroupFacetCollectorTest.cs                     |   4 +-
 .../PostingsHighlight/TestPostingsHighlighter.cs   |   6 +-
 src/Lucene.Net.Tests.Join/TestJoinUtil.cs          |   2 +-
 .../Classic/TestQueryParser.cs                     |  14 +-
 .../Flexible/Standard/TestStandardQP.cs            |  10 +-
 .../IndexAndTaxonomyReplicationClientTest.cs       |   2 +-
 .../IndexReplicationClientTest.cs                  |   2 +-
 src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs    |   6 +-
 .../Suggest/Analyzing/AnalyzingSuggesterTest.cs    |   2 +-
 .../Suggest/Analyzing/FuzzySuggesterTest.cs        |   4 +-
 .../Suggest/Analyzing/TestFreeTextSuggester.cs     |   2 +-
 .../Suggest/LookupBenchmarkTest.cs                 |   4 +-
 .../Analysis/TestGraphTokenizers.cs                |   2 +-
 .../Codecs/Lucene41/TestBlockPostingsFormat3.cs    |   2 +-
 .../Codecs/PerField/TestPerFieldDocValuesFormat.cs |   2 +-
 .../Index/TestBackwardsCompatibility.cs            |   2 +-
 .../Index/TestBackwardsCompatibility3x.cs          |   2 +-
 src/Lucene.Net.Tests/Index/TestCodecs.cs           |   6 +-
 src/Lucene.Net.Tests/Index/TestIndexWriter.cs      |   4 +-
 .../Index/TestIndexWriterMerging.cs                |   2 +-
 src/Lucene.Net.Tests/Index/TestIndexableField.cs   |   4 +-
 src/Lucene.Net.Tests/Index/TestLongPostings.cs     |   4 +-
 src/Lucene.Net.Tests/Index/TestNRTThreads.cs       |   2 +-
 src/Lucene.Net.Tests/Index/TestPayloads.cs         |   2 +-
 .../Index/TestPayloadsOnVectors.cs                 |   4 +-
 src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs  |   8 +-
 src/Lucene.Net.Tests/Index/TestStressIndexing2.cs  |   4 +-
 src/Lucene.Net.Tests/Index/TestStressNRT.cs        |   4 +-
 src/Lucene.Net.Tests/Index/TestTermsEnum.cs        |   2 +-
 .../Search/Spans/MultiSpansWrapper.cs              |   2 +-
 src/Lucene.Net.Tests/Search/TestBooleanScorer.cs   |   2 +-
 .../Search/TestConstantScoreQuery.cs               |   2 +-
 src/Lucene.Net.Tests/Search/TestFieldCache.cs      |   2 +-
 src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs |  10 +-
 .../Search/TestMultiThreadTermVectors.cs           |   2 +-
 .../Search/TestNumericRangeQuery32.cs              |   4 +-
 .../Search/TestNumericRangeQuery64.cs              |   4 +-
 .../Search/TestTimeLimitingCollector.cs            |   2 +-
 .../Util/Automaton/TestUTF32ToUTF8.cs              |   6 +-
 src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs          |   2 +-
 .../Util/Packed/TestEliasFanoDocIdSet.cs           |   2 +-
 .../Util/Packed/TestEliasFanoSequence.cs           |   6 +-
 src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs      |   2 +-
 src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs      |   2 +-
 src/Lucene.Net/Analysis/NumericTokenStream.cs      |   2 +-
 src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs  |   4 +-
 src/Lucene.Net/Analysis/Tokenizer.cs               |   2 +-
 src/Lucene.Net/Codecs/BlockTermState.cs            |   2 +-
 src/Lucene.Net/Codecs/BlockTreeTermsReader.cs      | 175 ++++++++--------
 src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs      |  78 +++++---
 src/Lucene.Net/Codecs/CodecUtil.cs                 |   2 +-
 .../CompressingStoredFieldsIndexWriter.cs          |   8 +-
 .../Compressing/CompressingStoredFieldsReader.cs   |  21 +-
 .../Compressing/CompressingStoredFieldsWriter.cs   |  19 +-
 .../Compressing/CompressingTermVectorsReader.cs    |  20 +-
 .../Compressing/CompressingTermVectorsWriter.cs    |  44 ++--
 .../Codecs/Compressing/CompressionMode.cs          |   6 +-
 src/Lucene.Net/Codecs/Compressing/LZ4.cs           |  18 +-
 src/Lucene.Net/Codecs/DocValuesConsumer.cs         |   4 +-
 src/Lucene.Net/Codecs/FieldsConsumer.cs            |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs   |  46 +++--
 .../Codecs/Lucene3x/Lucene3xNormsProducer.cs       |   6 +-
 .../Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs   |   6 +-
 .../Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs  |   4 +-
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs   |  17 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs  |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs  |   7 +-
 .../Codecs/Lucene3x/SegmentTermPositions.cs        |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs       |   6 +-
 src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs  |   6 +-
 src/Lucene.Net/Codecs/Lucene40/BitVector.cs        |  24 +--
 .../Codecs/Lucene40/Lucene40LiveDocsFormat.cs      |  14 +-
 .../Codecs/Lucene40/Lucene40PostingsFormat.cs      |   2 +-
 .../Codecs/Lucene40/Lucene40PostingsReader.cs      |  45 +++--
 .../Codecs/Lucene40/Lucene40StoredFieldsReader.cs  |  11 +-
 .../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs  |  13 +-
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs   |  27 +--
 .../Codecs/Lucene40/Lucene40TermVectorsWriter.cs   |  27 ++-
 src/Lucene.Net/Codecs/Lucene41/ForUtil.cs          |  25 ++-
 .../Codecs/Lucene41/Lucene41PostingsFormat.cs      |   4 +-
 .../Codecs/Lucene41/Lucene41PostingsReader.cs      |  22 +-
 .../Codecs/Lucene41/Lucene41PostingsWriter.cs      |  15 +-
 .../Codecs/Lucene41/Lucene41SkipReader.cs          |   2 +-
 .../Codecs/Lucene42/Lucene42NormsConsumer.cs       |   4 +-
 .../Codecs/Lucene45/Lucene45DocValuesConsumer.cs   |   4 +-
 .../Codecs/Lucene46/Lucene46FieldInfosWriter.cs    |   4 +-
 src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs      |   2 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs  |   2 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs  |   2 +-
 .../Codecs/PerField/PerFieldDocValuesFormat.cs     |  10 +-
 .../Codecs/PerField/PerFieldPostingsFormat.cs      |   8 +-
 src/Lucene.Net/Codecs/PostingsConsumer.cs          |   2 +-
 src/Lucene.Net/Codecs/TermVectorsWriter.cs         |  19 +-
 src/Lucene.Net/Codecs/TermsConsumer.cs             |  10 +-
 src/Lucene.Net/Index/AtomicReader.cs               |  11 +-
 src/Lucene.Net/Index/AtomicReaderContext.cs        |   2 +-
 src/Lucene.Net/Index/AutomatonTermsEnum.cs         |   8 +-
 src/Lucene.Net/Index/BitsSlice.cs                  |   4 +-
 src/Lucene.Net/Index/BufferedUpdatesStream.cs      |  57 +++---
 src/Lucene.Net/Index/ByteSliceReader.cs            |  22 +-
 src/Lucene.Net/Index/ByteSliceWriter.cs            |  12 +-
 src/Lucene.Net/Index/CheckIndex.cs                 |  30 +--
 src/Lucene.Net/Index/CompositeReader.cs            |   4 +-
 src/Lucene.Net/Index/CompositeReaderContext.cs     |   4 +-
 src/Lucene.Net/Index/ConcurrentMergeScheduler.cs   |   2 +-
 src/Lucene.Net/Index/DirectoryReader.cs            |   6 +-
 src/Lucene.Net/Index/DocFieldProcessor.cs          |   8 +-
 src/Lucene.Net/Index/DocTermOrds.cs                |  20 +-
 src/Lucene.Net/Index/DocValuesFieldUpdates.cs      |   4 +-
 src/Lucene.Net/Index/DocValuesProcessor.cs         |   4 +-
 src/Lucene.Net/Index/DocumentsWriter.cs            |  41 ++--
 src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs |   6 +-
 .../Index/DocumentsWriterFlushControl.cs           |  92 +++++----
 src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs  |  43 ++--
 src/Lucene.Net/Index/DocumentsWriterPerThread.cs   |  39 ++--
 .../Index/DocumentsWriterPerThreadPool.cs          |  24 +--
 .../Index/DocumentsWriterStallControl.cs           |   8 +-
 src/Lucene.Net/Index/FieldInfo.cs                  |  31 +--
 src/Lucene.Net/Index/FieldInfos.cs                 |  13 +-
 src/Lucene.Net/Index/FilteredTermsEnum.cs          |   6 +-
 src/Lucene.Net/Index/FlushPolicy.cs                |   6 +-
 src/Lucene.Net/Index/FreqProxTermsWriter.cs        |   2 +-
 .../Index/FreqProxTermsWriterPerField.cs           |  51 ++---
 src/Lucene.Net/Index/FrozenBufferedUpdates.cs      |   6 +-
 src/Lucene.Net/Index/IndexFileDeleter.cs           |  42 ++--
 src/Lucene.Net/Index/IndexFileNames.cs             |   4 +-
 src/Lucene.Net/Index/IndexFormatTooNewException.cs |   2 +-
 src/Lucene.Net/Index/IndexFormatTooOldException.cs |   4 +-
 src/Lucene.Net/Index/IndexWriter.cs                | 165 ++++++++-------
 src/Lucene.Net/Index/LogMergePolicy.cs             |   8 +-
 src/Lucene.Net/Index/MergePolicy.cs                |   8 +-
 src/Lucene.Net/Index/MergeState.cs                 |   4 +-
 src/Lucene.Net/Index/MultiBits.cs                  |  15 +-
 src/Lucene.Net/Index/MultiDocValues.cs             |  16 +-
 src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs  |   4 +-
 src/Lucene.Net/Index/MultiDocsEnum.cs              |   2 +-
 src/Lucene.Net/Index/MultiFields.cs                |  16 +-
 src/Lucene.Net/Index/MultiTerms.cs                 |   2 +-
 src/Lucene.Net/Index/MultiTermsEnum.cs             |  20 +-
 src/Lucene.Net/Index/NormsConsumer.cs              |   6 +-
 .../Index/NumericDocValuesFieldUpdates.cs          |   2 +-
 src/Lucene.Net/Index/OrdTermState.cs               |   2 +-
 src/Lucene.Net/Index/ParallelCompositeReader.cs    |   2 +-
 src/Lucene.Net/Index/PrefixCodedTerms.cs           |   4 +-
 src/Lucene.Net/Index/ReadersAndUpdates.cs          |  54 ++---
 src/Lucene.Net/Index/SegmentCoreReaders.cs         |   6 +-
 src/Lucene.Net/Index/SegmentDocValues.cs           |   4 +-
 src/Lucene.Net/Index/SegmentInfo.cs                |   4 +-
 src/Lucene.Net/Index/SegmentInfos.cs               |  10 +-
 src/Lucene.Net/Index/SegmentMerger.cs              |   4 +-
 src/Lucene.Net/Index/SegmentReader.cs              |  12 +-
 src/Lucene.Net/Index/SimpleMergedSegmentWarmer.cs  |   2 +-
 .../Index/SingletonSortedSetDocValues.cs           |   2 +-
 src/Lucene.Net/Index/SlowCompositeReaderWrapper.cs |   4 +-
 src/Lucene.Net/Index/SnapshotDeletionPolicy.cs     |   2 +-
 src/Lucene.Net/Index/SortedDocValuesTermsEnum.cs   |   4 +-
 src/Lucene.Net/Index/SortedDocValuesWriter.cs      |   4 +-
 .../Index/SortedSetDocValuesTermsEnum.cs           |   4 +-
 src/Lucene.Net/Index/SortedSetDocValuesWriter.cs   |   4 +-
 src/Lucene.Net/Index/StandardDirectoryReader.cs    |   9 +-
 src/Lucene.Net/Index/StoredFieldsProcessor.cs      |   6 +-
 src/Lucene.Net/Index/TermContext.cs                |  15 +-
 src/Lucene.Net/Index/TermVectorsConsumer.cs        |  12 +-
 .../Index/TermVectorsConsumerPerField.cs           |  12 +-
 src/Lucene.Net/Index/TermsHashPerField.cs          |   6 +-
 .../ThreadAffinityDocumentsWriterThreadPool.cs     |   6 +-
 src/Lucene.Net/Search/CachingWrapperFilter.cs      |   2 +-
 src/Lucene.Net/Search/CollectionStatistics.cs      |  11 +-
 src/Lucene.Net/Search/ConstantScoreAutoRewrite.cs  |   6 +-
 src/Lucene.Net/Search/ConstantScoreQuery.cs        |  12 +-
 src/Lucene.Net/Search/DisjunctionScorer.cs         |   4 +-
 src/Lucene.Net/Search/DocIdSetIterator.cs          |  11 +-
 src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs    |   2 +-
 src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs  |   2 +-
 src/Lucene.Net/Search/ExactPhraseScorer.cs         |   2 +-
 src/Lucene.Net/Search/FieldCacheImpl.cs            |  12 +-
 src/Lucene.Net/Search/FieldCacheRangeFilter.cs     |   4 +-
 src/Lucene.Net/Search/FieldCacheRewriteMethod.cs   |   2 +-
 src/Lucene.Net/Search/FieldComparator.cs           |  12 +-
 src/Lucene.Net/Search/FieldValueHitQueue.cs        |  14 +-
 src/Lucene.Net/Search/FilteredQuery.cs             |   8 +-
 src/Lucene.Net/Search/FuzzyTermsEnum.cs            |   2 +-
 src/Lucene.Net/Search/IndexSearcher.cs             |   6 +-
 src/Lucene.Net/Search/MinShouldMatchSumScorer.cs   |   4 +-
 src/Lucene.Net/Search/MultiPhraseQuery.cs          |   4 +-
 .../Search/MultiTermQueryWrapperFilter.cs          |   2 +-
 src/Lucene.Net/Search/NumericRangeQuery.cs         |  14 +-
 src/Lucene.Net/Search/PhraseQuery.cs               |   6 +-
 src/Lucene.Net/Search/QueryRescorer.cs             |   2 +-
 src/Lucene.Net/Search/ReferenceManager.cs          |   6 +-
 src/Lucene.Net/Search/ReqOptSumScorer.cs           |   7 +-
 src/Lucene.Net/Search/ScoringRewrite.cs            |  10 +-
 src/Lucene.Net/Search/SearcherManager.cs           |   4 +-
 .../Search/Similarities/SimilarityBase.cs          |   2 +-
 src/Lucene.Net/Search/SloppyPhraseScorer.cs        |   4 +-
 src/Lucene.Net/Search/SortField.cs                 |   2 +-
 src/Lucene.Net/Search/SortRescorer.cs              |   2 +-
 src/Lucene.Net/Search/Spans/NearSpansOrdered.cs    |   6 +-
 src/Lucene.Net/Search/Spans/SpanFirstQuery.cs      |   2 +-
 .../Search/Spans/SpanPositionRangeQuery.cs         |   2 +-
 src/Lucene.Net/Search/Spans/TermSpans.cs           |   2 +-
 src/Lucene.Net/Search/TermCollectingRewrite.cs     |   2 +-
 src/Lucene.Net/Search/TermQuery.cs                 |  10 +-
 src/Lucene.Net/Search/TermScorer.cs                |   2 +-
 src/Lucene.Net/Search/TermStatistics.cs            |   7 +-
 src/Lucene.Net/Search/TopDocs.cs                   |  10 +-
 src/Lucene.Net/Search/TopScoreDocCollector.cs      |  20 +-
 src/Lucene.Net/Search/TopTermsRewrite.cs           |  18 +-
 src/Lucene.Net/Store/BaseDirectory.cs              |   2 +-
 src/Lucene.Net/Store/BufferedIndexInput.cs         |   2 +-
 src/Lucene.Net/Store/ByteArrayDataOutput.cs        |   4 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs       |  11 +-
 src/Lucene.Net/Store/CompoundFileDirectory.cs      |   8 +-
 src/Lucene.Net/Store/CompoundFileWriter.cs         |  18 +-
 src/Lucene.Net/Store/DataInput.cs                  |   2 +-
 src/Lucene.Net/Store/DataOutput.cs                 |   4 +-
 src/Lucene.Net/Store/IOContext.cs                  |   9 +-
 src/Lucene.Net/Store/MMapDirectory.cs              |   2 +-
 src/Lucene.Net/Store/NIOFSDirectory.cs             |   6 +-
 src/Lucene.Net/Store/RAMOutputStream.cs            |   2 +-
 .../Store/RateLimitedDirectoryWrapper.cs           |   2 +-
 src/Lucene.Net/Store/SimpleFSDirectory.cs          |   4 +-
 src/Lucene.Net/Support/BitArrayExtensions.cs       |   2 +-
 src/Lucene.Net/Support/Collections.cs              |   2 +-
 src/Lucene.Net/Util/ArrayUtil.cs                   |  40 ++--
 src/Lucene.Net/Util/AttributeSource.cs             |   2 +-
 src/Lucene.Net/Util/Automaton/Automaton.cs         |   4 +-
 src/Lucene.Net/Util/Automaton/BasicOperations.cs   |   8 +-
 src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs |   8 +-
 .../Util/Automaton/DaciukMihovAutomatonBuilder.cs  |  17 +-
 .../Util/Automaton/Lev1ParametricDescription.cs    |   4 +-
 .../Util/Automaton/Lev1TParametricDescription.cs   |   4 +-
 .../Util/Automaton/Lev2ParametricDescription.cs    |   4 +-
 .../Util/Automaton/Lev2TParametricDescription.cs   |   4 +-
 .../Util/Automaton/LevenshteinAutomata.cs          |   2 +-
 src/Lucene.Net/Util/Automaton/SortedIntSet.cs      |   2 +-
 src/Lucene.Net/Util/Automaton/State.cs             |   2 +-
 src/Lucene.Net/Util/Automaton/Transition.cs        |   9 +-
 src/Lucene.Net/Util/Automaton/UTF32ToUTF8.cs       |   7 +-
 src/Lucene.Net/Util/BroadWord.cs                   |   4 +-
 src/Lucene.Net/Util/ByteBlockPool.cs               |   2 +-
 src/Lucene.Net/Util/BytesRef.cs                    |  12 +-
 src/Lucene.Net/Util/BytesRefArray.cs               |   2 +-
 src/Lucene.Net/Util/BytesRefHash.cs                |  44 ++--
 src/Lucene.Net/Util/CharsRef.cs                    |   4 +-
 src/Lucene.Net/Util/FilterIterator.cs              |   2 +-
 src/Lucene.Net/Util/FixedBitSet.cs                 |  39 ++--
 src/Lucene.Net/Util/Fst/Builder.cs                 |  56 ++++--
 src/Lucene.Net/Util/Fst/ByteSequenceOutputs.cs     |  34 +++-
 src/Lucene.Net/Util/Fst/BytesRefFSTEnum.cs         |   2 +-
 src/Lucene.Net/Util/Fst/BytesStore.cs              |  24 ++-
 src/Lucene.Net/Util/Fst/CharSequenceOutputs.cs     |  37 +++-
 src/Lucene.Net/Util/Fst/FST.cs                     |  54 ++---
 src/Lucene.Net/Util/Fst/FSTEnum.cs                 |  29 ++-
 src/Lucene.Net/Util/Fst/IntSequenceOutputs.cs      |  37 +++-
 src/Lucene.Net/Util/Fst/IntsRefFSTEnum.cs          |   2 +-
 src/Lucene.Net/Util/Fst/NoOutputs.cs               |  28 ++-
 src/Lucene.Net/Util/Fst/NodeHash.cs                |   2 +-
 src/Lucene.Net/Util/Fst/PairOutputs.cs             |  27 ++-
 src/Lucene.Net/Util/Fst/PositiveIntOutputs.cs      |  32 ++-
 src/Lucene.Net/Util/Fst/Util.cs                    |  12 +-
 src/Lucene.Net/Util/IndexableBinaryStringTools.cs  |   4 +-
 src/Lucene.Net/Util/InfoStream.cs                  |   2 +-
 src/Lucene.Net/Util/IntBlockPool.cs                |  17 +-
 src/Lucene.Net/Util/IntsRef.cs                     |   4 +-
 src/Lucene.Net/Util/LongBitSet.cs                  |  39 ++--
 src/Lucene.Net/Util/LongsRef.cs                    |   4 +-
 src/Lucene.Net/Util/MergedIterator.cs              |   2 +-
 src/Lucene.Net/Util/OfflineSorter.cs               |  15 +-
 src/Lucene.Net/Util/OpenBitSet.cs                  |  34 ++--
 src/Lucene.Net/Util/PForDeltaDocIdSet.cs           |  34 ++--
 .../Util/Packed/AbstractAppendingLongBuffer.cs     |  13 +-
 .../Util/Packed/AbstractBlockPackedWriter.cs       |   2 +-
 src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs |   6 +-
 src/Lucene.Net/Util/Packed/BlockPackedReader.cs    |   2 +-
 .../Util/Packed/BlockPackedReaderIterator.cs       |  12 +-
 src/Lucene.Net/Util/Packed/BlockPackedWriter.cs    |   2 +-
 src/Lucene.Net/Util/Packed/BulkOperation.cs        |   4 +-
 src/Lucene.Net/Util/Packed/BulkOperationPacked.cs  |  16 +-
 src/Lucene.Net/Util/Packed/Direct16.cs             |  20 +-
 src/Lucene.Net/Util/Packed/Direct32.cs             |  20 +-
 src/Lucene.Net/Util/Packed/Direct64.cs             |  18 +-
 src/Lucene.Net/Util/Packed/Direct8.cs              |  20 +-
 src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs     |  28 +--
 src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs     |   4 +-
 src/Lucene.Net/Util/Packed/GrowableWriter.cs       |   2 +-
 .../Util/Packed/MonotonicAppendingLongBuffer.cs    |   2 +-
 .../Util/Packed/MonotonicBlockPackedReader.cs      |   2 +-
 .../Util/Packed/MonotonicBlockPackedWriter.cs      |   4 +-
 src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs  |  18 +-
 src/Lucene.Net/Util/Packed/Packed64.cs             |  47 +++--
 src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs  |  52 +++--
 src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs   |  18 +-
 src/Lucene.Net/Util/Packed/PackedDataInput.cs      |   2 +-
 src/Lucene.Net/Util/Packed/PackedDataOutput.cs     |   2 +-
 src/Lucene.Net/Util/Packed/PackedInts.cs           |  88 ++++----
 src/Lucene.Net/Util/Packed/PackedReaderIterator.cs |  11 +-
 src/Lucene.Net/Util/Packed/PackedWriter.cs         |   9 +-
 src/Lucene.Net/Util/Packed/PagedMutable.cs         |   2 +-
 src/Lucene.Net/Util/PagedBytes.cs                  |  17 +-
 src/Lucene.Net/Util/QueryBuilder.cs                |  12 +-
 src/Lucene.Net/Util/RamUsageEstimator.cs           |  18 +-
 src/Lucene.Net/Util/RecyclingByteBlockAllocator.cs |   6 +-
 src/Lucene.Net/Util/RecyclingIntBlockAllocator.cs  |   6 +-
 src/Lucene.Net/Util/RollingBuffer.cs               |   9 +-
 src/Lucene.Net/Util/SentinelIntSet.cs              |   4 +-
 src/Lucene.Net/Util/Sorter.cs                      |   2 +-
 src/Lucene.Net/Util/TimSorter.cs                   |  18 +-
 src/Lucene.Net/Util/UnicodeUtil.cs                 |   4 +-
 src/Lucene.Net/Util/WAH8DocIdSet.cs                |  70 ++++---
 .../TestICUPostingsHighlighter.cs                  |   9 +-
 506 files changed, 3167 insertions(+), 2561 deletions(-)

diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
index bd3fa5b..f490dc0 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
@@ -114,7 +114,7 @@ namespace Lucene.Net.Analysis.CharFilters
             }
 
             int offset = offsets[(size == 0) ? 0 : size - 1];
-            Debugging.Assert(() => size == 0 || off >= offset,
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => size == 0 || off >= offset,
                 () => "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
 
             if (size == 0 || off != offsets[size - 1])
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
index eb28c1f..611e72b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
@@ -30953,7 +30953,7 @@ namespace Lucene.Net.Analysis.CharFilters
             /// </summary>
             internal int NextChar()
             {
-                Debugging.Assert(() => !IsRead, () => "Attempting to read past the end of a segment.");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !IsRead, () => "Attempting to read past the end of a segment.");
                 return m_buf[pos++];
             }
 
@@ -31378,7 +31378,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    Debugging.Assert(() => false, () => "Exception parsing code point '" + decimalCharRef + "'");
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing code point '" + decimalCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31638,7 +31638,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    Debugging.Assert(() => false, () => "Exception parsing hex code point '" + hexCharRef + "'");
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing hex code point '" + hexCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31901,7 +31901,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31910,7 +31910,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
                             }
                             // add (previously matched input length) + (this match length) - (substitution length)
                             cumulativeDiff += inputSegment.Length + YyLength - 2;
@@ -31932,7 +31932,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31941,7 +31941,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                             + surrogatePair.Substring(9, 14 - 9) + "'");
                             }
                             if (char.IsLowSurrogate(lowSurrogate))
@@ -31973,7 +31973,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -31986,7 +31986,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(10, 14 - 10) + "'");
                                 }
                                 // add (previously matched input length) + (this match length) - (substitution length)
@@ -32013,7 +32013,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -32025,7 +32025,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(9, 14 - 9) + "'");
                                 }
                                 if (char.IsLowSurrogate(lowSurrogate))
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
index 42d03df..a921887 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
@@ -136,7 +136,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         if (!FST.TargetHasArcs(arc))
                         {
                             // Fast pass for single character match:
-                            Debugging.Assert(() => arc.IsFinal);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                             lastMatchLen = 1;
                             lastMatch = arc.Output;
                         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
index 3858445..7186c94 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
@@ -54,7 +54,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         map.ReadFirstRealTargetArc(scratchArc.Target, scratchArc, fstReader);
                         while (true)
                         {
-                            Debugging.Assert(() => scratchArc.Label != FST.END_LABEL);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchArc.Label != FST.END_LABEL);
                             cachedRootArcs[Convert.ToChar((char)scratchArc.Label)] = (new FST.Arc<CharsRef>()).CopyFrom(scratchArc);
                             if (scratchArc.IsLast)
                             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
index 518651b..b60791e 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
@@ -110,7 +110,7 @@ namespace Lucene.Net.Analysis.Compound
         {
             if (m_tokens.Count > 0)
             {
-                Debugging.Assert(() => current != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => current != null);
                 CompoundToken token = m_tokens.Dequeue();
                 RestoreState(current); // keep all other attributes untouched
                 m_termAtt.SetEmpty().Append(token.Text);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
index 7aa674e..bf49cde 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis.Gl
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = unification.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
index f770e91..305f0d1 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
@@ -375,7 +375,7 @@ namespace Lucene.Net.Analysis.Hunspell
                 strip.CopyTo(0, stripData, currentOffset, strip.Length - 0);
                 currentOffset += strip.Length;
             }
-            Debugging.Assert(() => currentIndex == seenStrips.Count);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentIndex == seenStrips.Count);
             stripOffsets[currentIndex] = currentOffset;
         }
 
@@ -424,7 +424,7 @@ namespace Lucene.Net.Analysis.Hunspell
 
             for (int i = 0; i < numLines; i++)
             {
-                Debugging.Assert(() => affixWriter.Position == currentAffix << 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => affixWriter.Position == currentAffix << 3);
                 string line = reader.ReadLine();
                 string[] ruleArgs = whitespacePattern.Split(line).TrimEnd();
 
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
index 0b40b56..4ad0ee1 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
@@ -210,7 +210,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            Debugging.Assert(() => prevFlag >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, false);
                         }
                         else
@@ -279,7 +279,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            Debugging.Assert(() => prevFlag >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, previousWasPrefix);
                         }
                         else
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
index d47ed47..aa76247 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Analysis.Miscellaneous
         {
             if (state != null)
             {
-                Debugging.Assert(() => preserveOriginal, () => "state should only be captured if preserveOriginal is true");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => preserveOriginal, () => "state should only be captured if preserveOriginal is true");
                 RestoreState(state);
                 posIncAttr.PositionIncrement = 0;
                 state = null;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
index 4855e8d..225fae8 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
@@ -35,11 +35,11 @@ namespace Lucene.Net.Analysis.Miscellaneous
         public SingleTokenTokenStream(Token token) 
             : base(Token.TOKEN_ATTRIBUTE_FACTORY)
         {
-            Debugging.Assert(() => token != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => token != null);
             this.singleToken = (Token)token.Clone();
 
             tokenAtt = AddAttribute<ICharTermAttribute>();
-            Debugging.Assert(() => tokenAtt is Token);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => tokenAtt is Token);
         }
 
         public override sealed bool IncrementToken()
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
index 1327200..60bc879 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
@@ -232,7 +232,7 @@ namespace Lucene.Net.Analysis.NGram
                 {
                     if (bufferStart + 1 + minGram > bufferEnd)
                     {
-                        Debugging.Assert(() => exhausted);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => exhausted);
                         return false;
                     }
                     Consume();
@@ -295,7 +295,7 @@ namespace Lucene.Net.Analysis.NGram
         public override sealed void End()
         {
             base.End();
-            Debugging.Assert(() => bufferStart <= bufferEnd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => bufferStart <= bufferEnd);
             int endOffset = offset;
             for (int i = bufferStart; i < bufferEnd; ++i)
             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
index 8ca48d4..e901768 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
@@ -155,7 +155,7 @@ namespace Lucene.Net.Analysis.Pattern
         {
             if (currentMatcher != -1 && NextCapture())
             {
-                Debugging.Assert(() => state != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
                 ClearAttributes();
                 RestoreState(state);
                 int start = matchers[currentMatcher].Groups[currentGroup[currentMatcher]].Index;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
index cdd1ece..8943de0 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
@@ -46,7 +46,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = adverb.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
index f1b4d6a..594c88b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
@@ -305,7 +305,7 @@ namespace Lucene.Net.Analysis.Pt
             {
                 throw new Exception("Illegal Step header specified at line " /*+ r.LineNumber*/); // TODO Line number
             }
-            //Debugging.Assert(() => headerPattern.GetGroupNumbers().Length == 4); // Not possible to read the number of groups that matched in .NET
+            //if (Debugging.AssertsEnabled) Debugging.Assert(() => headerPattern.GetGroupNumbers().Length == 4); // Not possible to read the number of groups that matched in .NET
             string name = matcher.Groups[1].Value;
             int min = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture);
             int type = int.Parse(matcher.Groups[3].Value, CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
index 52adde9..a0c0786 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis.Synonym
 
             public virtual CharsRef PullNext()
             {
-                Debugging.Assert(() => upto < count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < count);
                 lastEndOffset = endOffsets[upto];
                 lastPosLength = posLengths[upto];
                 CharsRef result = outputs[upto++];
@@ -306,7 +306,7 @@ namespace Lucene.Net.Analysis.Synonym
             nextWrite = RollIncr(nextWrite);
 
             // Buffer head should never catch up to tail:
-            Debugging.Assert(() => nextWrite != nextRead);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextWrite != nextRead);
         }
 
         /*
@@ -325,7 +325,7 @@ namespace Lucene.Net.Analysis.Synonym
         {
             //System.out.println("\nS: parse");
 
-            Debugging.Assert(() => inputSkipCount == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputSkipCount == 0);
 
             int curNextRead = nextRead;
 
@@ -337,7 +337,7 @@ namespace Lucene.Net.Analysis.Synonym
             BytesRef pendingOutput = fst.Outputs.NoOutput;
             fst.GetFirstArc(scratchArc);
 
-            Debugging.Assert(() => scratchArc.Output == fst.Outputs.NoOutput);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchArc.Output == fst.Outputs.NoOutput);
 
             int tokenCount = 0;
 
@@ -364,7 +364,7 @@ namespace Lucene.Net.Analysis.Synonym
                     else
                     {
                         //System.out.println("  input.incrToken");
-                        Debugging.Assert(() => futureInputs[nextWrite].consumed);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => futureInputs[nextWrite].consumed);
                         // Not correct: a syn match whose output is longer
                         // than its input can set future inputs keepOrig
                         // to true:
@@ -480,7 +480,7 @@ namespace Lucene.Net.Analysis.Synonym
             }
             else
             {
-                Debugging.Assert(() => finished);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => finished);
             }
 
             //System.out.println("  parse done inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead + " nextWrite=" + nextWrite);
@@ -510,7 +510,7 @@ namespace Lucene.Net.Analysis.Synonym
                         int outputLen = chIDX - lastStart;
                         // Caller is not allowed to have empty string in
                         // the output:
-                        Debugging.Assert(() => outputLen > 0, () => "output contains empty string: " + scratchChars);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => outputLen > 0, () => "output contains empty string: " + scratchChars);
                         int endOffset;
                         int posLen;
                         if (chIDX == chEnd && lastStart == scratchChars.Offset)
@@ -536,7 +536,7 @@ namespace Lucene.Net.Analysis.Synonym
                         lastStart = 1 + chIDX;
                         //System.out.println("  slot=" + outputUpto + " keepOrig=" + keepOrig);
                         outputUpto = RollIncr(outputUpto);
-                        Debugging.Assert(() => futureOutputs[outputUpto].posIncr == 1, () => "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => futureOutputs[outputUpto].posIncr == 1, () => "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
                     }
                 }
             }
@@ -602,7 +602,7 @@ namespace Lucene.Net.Analysis.Synonym
                         {
                             // Pass-through case: return token we just pulled
                             // but didn't capture:
-                            Debugging.Assert(() => inputSkipCount == 1, () => "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputSkipCount == 1, () => "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
                         }
                         input.Reset();
                         if (outputs.count > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
index 99c743a..539233e 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
@@ -173,8 +173,11 @@ namespace Lucene.Net.Analysis.Synonym
                     throw new ArgumentException("output.length must be > 0 (got " + output.Length + ")");
                 }
 
-                Debugging.Assert(() => !HasHoles(input), () => "input has holes: " + input);
-                Debugging.Assert(() => !HasHoles(output), () => "output has holes: " + output);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => !HasHoles(input), () => "input has holes: " + input);
+                    Debugging.Assert(() => !HasHoles(output), () => "output has holes: " + output);
+                }
 
                 //System.out.println("fmap.add input=" + input + " numInputWords=" + numInputWords + " output=" + output + " numOutputWords=" + numOutputWords);
                 UnicodeUtil.UTF16toUTF8(output.Chars, output.Offset, output.Length, utf8Scratch);
@@ -281,7 +284,7 @@ namespace Lucene.Net.Analysis.Synonym
 
                     scratch.Grow(estimatedSize);
                     scratchOutput.Reset(scratch.Bytes, scratch.Offset, scratch.Bytes.Length);
-                    Debugging.Assert(() => scratch.Offset == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => scratch.Offset == 0);
 
                     // now write our output data:
                     int count = 0;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
index 434d2c4..a4be3e6 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
@@ -632,7 +632,7 @@ namespace Lucene.Net.Analysis.Util
 
         private void Rehash()
         {
-            Debugging.Assert(() => keys.Length == values.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => keys.Length == values.Length);
             int newSize = 2 * keys.Length;
             char[][] oldkeys = keys;
             MapValue[] oldvalues = values;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
index 9669dd5..9eda606 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
@@ -169,7 +169,7 @@ namespace Lucene.Net.Analysis.Util
                 {
                     if (length == 0) // start of token
                     {
-                        Debugging.Assert(() => start == -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => start == -1);
                         start = offset + bufferIndex - charCount;
                         end = start;
                     } // check if a supplementary could run out of bounds
@@ -191,7 +191,7 @@ namespace Lucene.Net.Analysis.Util
             }
 
             termAtt.Length = length;
-            Debugging.Assert(() => start != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => start != -1);
             offsetAtt.SetOffset(CorrectOffset(start), finalOffset = CorrectOffset(end));
             return true;
         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
index 9c2f505..3822951 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
@@ -176,8 +176,11 @@ namespace Lucene.Net.Analysis.Util
         /// <param name="length"> the number of characters in the buffer to lower case </param>
         public virtual void ToLower(char[] buffer, int offset, int length) // LUCENENET specific - marked virtual so we can override the default
         {
-            Debugging.Assert(() => buffer.Length >= length);
-            Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => buffer.Length >= length);
+                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+            }
 
             // Slight optimization, eliminating a few method calls internally
             CultureInfo.InvariantCulture.TextInfo
@@ -207,8 +210,11 @@ namespace Lucene.Net.Analysis.Util
         /// <param name="length"> the number of characters in the buffer to lower case </param>
         public virtual void ToUpper(char[] buffer, int offset, int length) // LUCENENET specific - marked virtual so we can override the default
         {
-            Debugging.Assert(() => buffer.Length >= length);
-            Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => buffer.Length >= length);
+                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+            }
 
             // Slight optimization, eliminating a few method calls internally
             CultureInfo.InvariantCulture.TextInfo
@@ -349,7 +355,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                Debugging.Assert(() => buffer.Buffer.Length >= 2);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Buffer.Length >= 2);
                 if (numChars < 2 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 2 and <= the buffer size");
@@ -470,7 +476,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                Debugging.Assert(() => buffer.Buffer.Length >= 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Buffer.Length >= 1);
                 if (numChars < 1 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 1 and <= the buffer size");
@@ -533,8 +539,11 @@ namespace Lucene.Net.Analysis.Util
         {
             public override void ToLower(char[] buffer, int offset, int limit)
             {
-                Debugging.Assert(() => buffer.Length >= limit);
-                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => buffer.Length >= limit);
+                    Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                }
 
                 for (int i = offset; i < limit;)
                 {
@@ -546,8 +555,11 @@ namespace Lucene.Net.Analysis.Util
 
             public override void ToUpper(char[] buffer, int offset, int limit)
             {
-                Debugging.Assert(() => buffer.Length >= limit);
-                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => buffer.Length >= limit);
+                    Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                }
 
                 for (int i = offset; i < limit;)
                 {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
index e4a7086..49d2d81 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
@@ -108,10 +108,10 @@ namespace Lucene.Net.Analysis.Util
             else
             {
                 // Cannot read from future (except by 1):
-                Debugging.Assert(() => pos < nextPos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < nextPos);
 
                 // Cannot read from already freed past:
-                Debugging.Assert(() => nextPos - pos <= count, () => "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => nextPos - pos <= count, () => "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
 
                 return buffer[GetIndex(pos)];
             }
@@ -130,15 +130,18 @@ namespace Lucene.Net.Analysis.Util
             {
                 // Wrap:
                 index += buffer.Length;
-                Debugging.Assert(() => index >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => index >= 0);
             }
             return index;
         }
 
         public char[] Get(int posStart, int length)
         {
-            Debugging.Assert(() => length > 0);
-            Debugging.Assert(() => InBounds(posStart), () => "posStart=" + posStart + " length=" + length);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => length > 0);
+                Debugging.Assert(() => InBounds(posStart), () => "posStart=" + posStart + " length=" + length);
+            }
             //System.out.println("    buffer.Get posStart=" + posStart + " len=" + length);
 
             int startIndex = GetIndex(posStart);
@@ -166,11 +169,17 @@ namespace Lucene.Net.Analysis.Util
         /// </summary>
         public void FreeBefore(int pos)
         {
-            Debugging.Assert(() => pos >= 0);
-            Debugging.Assert(() => pos <= nextPos);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => pos >= 0);
+                Debugging.Assert(() => pos <= nextPos);
+            }
             int newCount = nextPos - pos;
-            Debugging.Assert(() => newCount <= count, () => "newCount=" + newCount + " count=" + count);
-            Debugging.Assert(() => newCount <= buffer.Length, () => "newCount=" + newCount + " buf.length=" + buffer.Length);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => newCount <= count, () => "newCount=" + newCount + " count=" + count);
+                Debugging.Assert(() => newCount <= buffer.Length, () => "newCount=" + newCount + " buf.length=" + buffer.Length);
+            }
             count = newCount;
         }
     }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
index 23cbfae..39c6594 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
@@ -184,7 +184,7 @@ namespace Lucene.Net.Analysis.Util
         /// commons-io's readFully, but without bugs if offset != 0 </summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
index 9c8d61c..d4eb3e7 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
@@ -117,7 +117,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int Delete(char[] s, int pos, int len)
         {
-            Debugging.Assert(() => pos < len);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < len);
             if (pos < len - 1) // don't arraycopy if asked to delete last character
             {
                 Array.Copy(s, pos + 1, s, pos, len - pos - 1);
@@ -135,7 +135,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int DeleteN(char[] s, int pos, int len, int nChars)
         {
-            Debugging.Assert(() => pos + nChars <= len);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos + nChars <= len);
             if (pos + nChars < len) // don't arraycopy if asked to delete the last characters
             {
                 Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
index 981e073..fcd4bb0 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
@@ -128,7 +128,7 @@ namespace Lucene.Net.Analysis.Icu
                 bool hasRemainingChars = CharacterUtils.GetInstance(LuceneVersion.LUCENE_CURRENT).Fill(tmpBuffer, m_input);
 #pragma warning restore 612, 618
 
-                Debugging.Assert(() => tmpBuffer.Offset == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => tmpBuffer.Offset == 0);
                 inputBuffer.Append(tmpBuffer.Buffer, 0, tmpBuffer.Length);
 
                 if (hasRemainingChars == false)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
index 213fa2f..9eb4d51 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
@@ -194,7 +194,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
         /// <summary>commons-io's readFully, but without bugs if offset != 0</summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
index c487089..8629acd 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public virtual void Inform(IResourceLoader loader)
         {
-            Debugging.Assert(() => tailored != null, () => "init must be called first!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => tailored != null, () => "init must be called first!");
             if (tailored.Count == 0)
             {
                 config = new DefaultICUTokenizerConfig(cjkAsWords, myanmarAsWords);
@@ -162,7 +162,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
         {
-            Debugging.Assert(() => config != null, () => "inform must be called first!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => config != null, () => "inform must be called first!");
             return new ICUTokenizer(factory, input, config);
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
index 04ca422..354c377 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
         {
             if (useCache && ch >= 0x3040 && ch <= cacheCeiling)
             {
-                Debugging.Assert(() => ch != FST.END_LABEL);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => ch != FST.END_LABEL);
                 FST.Arc<long?> result = rootCache[ch - 0x3040];
                 if (result == null)
                 {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
index aca253c..617f748 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
@@ -89,8 +89,11 @@ namespace Lucene.Net.Analysis.Ja
                 string toNodeID = GetNodeID(pos, bestIDX);
                 string fromNodeID = GetNodeID(backPos, backIDX);
 
-                Debugging.Assert(() => !bestPathMap.ContainsKey(fromNodeID));
-                Debugging.Assert(() => !bestPathMap.Values.Contains(toNodeID));
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => !bestPathMap.ContainsKey(fromNodeID));
+                    Debugging.Assert(() => !bestPathMap.Values.Contains(toNodeID));
+                }
                 bestPathMap[fromNodeID] = toNodeID;
                 pos = backPos;
                 bestIDX = backIDX;
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
index 931d70e..fb899c7 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
@@ -133,7 +133,7 @@ namespace Lucene.Net.Analysis.Ja
 
             // Make katakana dakuten map from hiragana map
             char codePointDifference = (char)('\u30ab' - '\u304b'); // カ - か
-            Debugging.Assert(() => h2d.Length == k2d.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => h2d.Length == k2d.Length);
             for (int i = 0; i < k2d.Length; i++)
             {
                 k2d[i] = (char)(h2d[i] + codePointDifference);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
index 2d3c993..8210652 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis.Ja
             int leftID = dict.GetLeftId(wordID);
             int leastCost = int.MaxValue;
             int leastIDX = -1;
-            Debugging.Assert(() => fromPosData.count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => fromPosData.count > 0);
             for (int idx = 0; idx < fromPosData.count; idx++)
             {
                 // Cost is path cost so far, plus word cost (added at
@@ -356,7 +356,7 @@ namespace Lucene.Net.Analysis.Ja
             }
 
             //positions.get(endPos).add(leastCost, dict.getRightId(wordID), fromPosData.pos, leastIDX, wordID, type);
-            Debugging.Assert(() => leftID == dict.GetRightId(wordID));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftID == dict.GetRightId(wordID));
             positions.Get(endPos).Add(leastCost, leftID, fromPosData.pos, leastIDX, wordID, type);
         }
 
@@ -387,7 +387,7 @@ namespace Lucene.Net.Analysis.Ja
             int position = token.Position;
             int length = token.Length;
             ClearAttributes();
-            Debugging.Assert(() => length > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => length > 0);
             //System.out.println("off=" + token.getOffset() + " len=" + length + " vs " + token.getSurfaceForm().length);
             termAtt.CopyBuffer(token.SurfaceForm, token.Offset, length);
             offsetAtt.SetOffset(CorrectOffset(position), CorrectOffset(position + length));
@@ -402,7 +402,7 @@ namespace Lucene.Net.Analysis.Ja
             }
             else
             {
-                Debugging.Assert(() => token.Position > lastTokenPos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => token.Position > lastTokenPos);
                 posIncAtt.PositionIncrement = 1;
                 posLengthAtt.PositionLength = 1;
             }
@@ -511,7 +511,7 @@ namespace Lucene.Net.Analysis.Ja
                     }
 
                     // We will always have at least one live path:
-                    Debugging.Assert(() => leastIDX != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => leastIDX != -1);
 
                     // Second pass: prune all but the best path:
                     for (int pos2 = pos; pos2 < positions.GetNextPos(); pos2++)
@@ -544,7 +544,7 @@ namespace Lucene.Net.Analysis.Ja
                     if (pos != leastPosData.pos)
                     {
                         // We jumped into a future position:
-                        Debugging.Assert(() => pos < leastPosData.pos);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < leastPosData.pos);
                         pos = leastPosData.pos;
                     }
 
@@ -913,10 +913,10 @@ namespace Lucene.Net.Analysis.Ja
             {
                 //System.out.println("BT: back pos=" + pos + " bestIDX=" + bestIDX);
                 Position posData = positions.Get(pos);
-                Debugging.Assert(() => bestIDX < posData.count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => bestIDX < posData.count);
 
                 int backPos = posData.backPos[bestIDX];
-                Debugging.Assert(() => backPos >= lastBackTracePos, () => "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => backPos >= lastBackTracePos, () => "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
                 int length = pos - backPos;
                 JapaneseTokenizerType backType = posData.backType[bestIDX];
                 int backID = posData.backID[bestIDX];
@@ -989,7 +989,7 @@ namespace Lucene.Net.Analysis.Ja
                         if (leastIDX != -1 && leastCost <= maxCost && posData.backPos[leastIDX] != backPos)
                         {
                             // We should have pruned the altToken from the graph:
-                            Debugging.Assert(() => posData.backPos[leastIDX] != backPos);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => posData.backPos[leastIDX] != backPos);
 
                             // Save the current compound token, to output when
                             // this alternate path joins back:
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Analysis.Ja
                 }
 
                 int offset = backPos - lastBackTracePos;
-                Debugging.Assert(() => offset >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => offset >= 0);
 
                 if (altToken != null && altToken.Position >= backPos)
                 {
@@ -1035,7 +1035,7 @@ namespace Lucene.Net.Analysis.Ja
                     // The pruning we did when we created the altToken
                     // ensures that the back trace will align back with
                     // the start of the altToken:
-                    Debugging.Assert(() => altToken.Position == backPos, () => altToken.Position + " vs " + backPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => altToken.Position == backPos, () => altToken.Position + " vs " + backPos);
 
                     // NOTE: not quite right: the compound token may
                     // have had all punctuation back traced so far, but
@@ -1060,7 +1060,7 @@ namespace Lucene.Net.Analysis.Ja
                         {
                             Console.WriteLine("    discard all-punctuation altToken=" + altToken);
                         }
-                        Debugging.Assert(() => discardPunctuation);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => discardPunctuation);
                     }
                     altToken = null;
                 }
@@ -1355,7 +1355,7 @@ namespace Lucene.Net.Analysis.Ja
         {
             count = 0;
             // forwardCount naturally resets after it runs:
-            Debugging.Assert(() => forwardCount == 0, () => "pos=" + pos + " forwardCount=" + forwardCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => forwardCount == 0, () => "pos=" + pos + " forwardCount=" + forwardCount);
         }
     }
 
@@ -1432,13 +1432,13 @@ namespace Lucene.Net.Analysis.Ja
                     nextWrite = 0;
                 }
                 // Should have already been reset:
-                Debugging.Assert(() => positions[nextWrite].count == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => positions[nextWrite].count == 0);
                 positions[nextWrite++].pos = nextPos++;
                 count++;
             }
-            Debugging.Assert(() => InBounds(pos));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => InBounds(pos));
             int index = GetIndex(pos);
-            Debugging.Assert(() => positions[index].pos == pos);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => positions[index].pos == pos);
             return positions[index];
         }
 
@@ -1466,8 +1466,11 @@ namespace Lucene.Net.Analysis.Ja
         public void FreeBefore(int pos)
         {
             int toFree = count - (nextPos - pos);
-            Debugging.Assert(() => toFree >= 0);
-            Debugging.Assert(() => toFree <= count);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => toFree >= 0);
+                Debugging.Assert(() => toFree <= count);
+            }
             int index = nextWrite - count;
             if (index < 0)
             {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
index ecb270d..7df6295 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             for (int i = 4; i < 8; i++)
             {
                 string part = entry[i];
-                Debugging.Assert(() => part.Length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => part.Length > 0);
                 if (!"*".Equals(part, StringComparison.Ordinal))
                 {
                     if (sb.Length > 0)
@@ -118,8 +118,11 @@ namespace Lucene.Net.Analysis.Ja.Util
                 flags |= BinaryDictionary.HAS_PRONUNCIATION;
             }
 
-            Debugging.Assert(() => leftId == rightId);
-            Debugging.Assert(() => leftId < 4096); // there are still unused bits
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => leftId == rightId);
+                Debugging.Assert(() => leftId < 4096); // there are still unused bits
+            }
                                          // add pos mapping
             int toFill = 1 + leftId - posDict.Count;
             for (int i = 0; i < toFill; i++)
@@ -128,7 +131,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
 
             string existing = posDict[leftId];
-            Debugging.Assert(() => existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
             posDict[leftId] = fullPOSData;
 
             m_buffer.PutInt16((short)(leftId << 3 | flags));
@@ -136,7 +139,7 @@ namespace Lucene.Net.Analysis.Ja.Util
 
             if ((flags & BinaryDictionary.HAS_BASEFORM) != 0)
             {
-                Debugging.Assert(() => baseForm.Length < 16);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => baseForm.Length < 16);
                 int shared = SharedPrefix(entry[0], baseForm);
                 int suffix = baseForm.Length - shared;
                 m_buffer.Put((byte)(shared << 4 | suffix));
@@ -237,11 +240,11 @@ namespace Lucene.Net.Analysis.Ja.Util
 
         public virtual void AddMapping(int sourceId, int wordId)
         {
-            Debugging.Assert(() => wordId > lastWordId, () => "words out of order: " + wordId + " vs lastID: " + lastWordId);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => wordId > lastWordId, () => "words out of order: " + wordId + " vs lastID: " + lastWordId);
 
             if (sourceId > lastSourceId)
             {
-                Debugging.Assert(() => sourceId > lastSourceId, () => "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId > lastSourceId, () => "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
                 targetMapOffsets = ArrayUtil.Grow(targetMapOffsets, sourceId + 1);
                 for (int i = lastSourceId + 1; i <= sourceId; i++)
                 {
@@ -250,7 +253,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
             else
             {
-                Debugging.Assert(() => sourceId == lastSourceId);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId == lastSourceId);
             }
 
             targetMap = ArrayUtil.Grow(targetMap, targetMapEndOffset + 1);
@@ -305,7 +308,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 for (int ofs = 0; ofs < targetMapEndOffset; ofs++)
                 {
                     int val = targetMap[ofs], delta = val - prev;
-                    Debugging.Assert(() => delta >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0);
                     if (ofs == targetMapOffsets[sourceId])
                     {
                         @out.WriteVInt32((delta << 1) | 0x01);
@@ -317,7 +320,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     }
                     prev += delta;
                 }
-                Debugging.Assert(() => sourceId == numSourceIds, () => "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId == numSourceIds, () => "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
             }
         }
 
@@ -341,7 +344,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     else
                     {
                         string[] data = CSVUtil.Parse(s);
-                        Debugging.Assert(() => data.Length == 3, () => "malformed pos/inflection: " + s);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => data.Length == 3, () => "malformed pos/inflection: " + s);
                         @out.WriteString(data[0]);
                         @out.WriteString(data[1]);
                         @out.WriteString(data[2]);
@@ -370,7 +373,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     @out.WriteByte(m_buffer.Get());
                 }
 
-                Debugging.Assert(() => m_buffer.Remaining == 0L);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_buffer.Remaining == 0L);
             }
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
index a653cdc..3e66621 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
@@ -41,12 +41,12 @@ namespace Lucene.Net.Analysis.Ja.Util
                 string line = streamReader.ReadLine();
                 string[] dimensions = whiteSpaceRegex.Split(line).TrimEnd();
 
-                Debugging.Assert(() => dimensions.Length == 2);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => dimensions.Length == 2);
 
                 int forwardSize = int.Parse(dimensions[0], CultureInfo.InvariantCulture);
                 int backwardSize = int.Parse(dimensions[1], CultureInfo.InvariantCulture);
 
-                Debugging.Assert(() => forwardSize > 0 && backwardSize > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => forwardSize > 0 && backwardSize > 0);
 
                 ConnectionCostsWriter costs = new ConnectionCostsWriter(forwardSize, backwardSize);
 
@@ -54,7 +54,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 {
                     string[] fields = whiteSpaceRegex.Split(line).TrimEnd();
 
-                    Debugging.Assert(() => fields.Length == 3);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == 3);
 
                     int forwardId = int.Parse(fields[0], CultureInfo.InvariantCulture);
                     int backwardId = int.Parse(fields[1], CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
index 9eea786..e49253e 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
@@ -63,10 +63,10 @@ namespace Lucene.Net.Analysis.Ja.Util
                 @out.WriteVInt32(forwardSize);
                 @out.WriteVInt32(backwardSize);
                 int last = 0;
-                Debugging.Assert(() => costs.Length == backwardSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => costs.Length == backwardSize);
                 foreach (short[] a in costs)
                 {
-                    Debugging.Assert(() => a.Length == forwardSize);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => a.Length == forwardSize);
                     for (int i = 0; i < a.Length; i++)
                     {
                         int delta = (int)a[i] - last;
diff --git a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
index 4a17a01..641a400 100644
--- a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
+++ b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
@@ -85,7 +85,7 @@ namespace Lucene.Net.Analysis.Phonetic
 
             if (matcher.Success)
             {
-                Debugging.Assert(() => state != null && encoded != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null && encoded != null);
                 RestoreState(state);
 
                 int start = matcher.Index;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
index d962a24..d7ea253 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
@@ -42,7 +42,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Utils
                                IList<TokenFilterFactory> tokenFilterFactories)
         {
             this.charFilterFactories = charFilterFactories;
-            Debugging.Assert(() => null != tokenizerFactory);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => null != tokenizerFactory);
             this.tokenizerFactory = tokenizerFactory;
             this.tokenFilterFactories = tokenFilterFactories;
         }
diff --git a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
index 5a357c8..633599f 100644
--- a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
+++ b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
@@ -242,7 +242,7 @@ namespace Lucene.Net.Benchmarks.Quality
                     }
                 }
             }
-            Debugging.Assert(() => m > 0, () => "Fishy: no \"good\" queries!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0, () => "Fishy: no \"good\" queries!");
             // take average: times go by all queries, other measures go by "good" queries only.
             avg.searchTime /= stats.Length;
             avg.docNamesExtractTime /= stats.Length;
diff --git a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
index 2f8ba27..4f51d9a 100644
--- a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
+++ b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
@@ -73,7 +73,7 @@ namespace Lucene.Net.Benchmarks.Quality.Trec
                     st.MoveNext();
                     bool relevant = !zero.Equals(st.Current, StringComparison.Ordinal);
                     // LUCENENET: don't call st.NextToken() unless the condition fails.
-                    Debugging.Assert(() => st.RemainingTokens == 0, () => "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => st.RemainingTokens == 0, () => "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
                     if (relevant)
                     { // only keep relevant docs
                         if (curr == null || !curr.queryID.Equals(queryID, StringComparison.Ordinal))
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
index e33c4a9..d9c8ccf 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
@@ -127,7 +127,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 {
                     int field = input.ReadVInt32();
                     long numTerms = input.ReadVInt64();
-                    Debugging.Assert(() => numTerms >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms >= 0);
                     long termsStartPointer = input.ReadVInt64();
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : input.ReadVInt64();
@@ -234,7 +234,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
         public override Terms GetTerms(string field)
         {
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
 
             FieldReader result;
             fields.TryGetValue(field, out result);
@@ -258,7 +258,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldReader(BlockTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int longsSize)
             {
-                Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
 
                 this.outerInstance = outerInstance;
 
@@ -449,7 +449,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                         // Block must exist since, at least, the indexed term
                         // is in the block:
-                        Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
 
                         indexIsCurrent = true;
                         didIndexNext = false;
@@ -537,7 +537,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 // Target's prefix is before the common prefix
                                 // of this block, so we position to start of
                                 // block and return NOT_FOUND:
-                                Debugging.Assert(() => state.TermBlockOrd == 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TermBlockOrd == 0);
 
                                 int suffix = termSuffixesReader.ReadVInt32();
                                 term.Length = termBlockPrefix + suffix;
@@ -642,7 +642,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // cross another index term (besides the first
                         // one) while we are scanning:
 
-                        Debugging.Assert(() => indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexIsCurrent);
 
                         if (!NextBlock())
                         {
@@ -665,7 +665,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // works properly:
                     if (seekPending)
                     {
-                        Debugging.Assert(() => !indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !indexIsCurrent);
                         input.Seek(state.BlockFilePointer);
                         int pendingSeekCount = state.TermBlockOrd;
                         bool result = NextBlock();
@@ -675,12 +675,12 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // Block must exist since seek(TermState) was called w/ a
                         // TermState previously returned by this enum when positioned
                         // on a real term:
-                        Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
 
                         while (state.TermBlockOrd < pendingSeekCount)
                         {
                             BytesRef nextResult = _next();
-                            Debugging.Assert(() => nextResult != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextResult != null);
                         }
                         seekPending = false;
                         state.Ord = savOrd;
@@ -769,8 +769,11 @@ namespace Lucene.Net.Codecs.BlockTerms
                 public override void SeekExact(BytesRef target, TermState otherState)
                 {
                     //System.out.println("BTR.seekExact termState target=" + target.utf8ToString() + " " + target + " this=" + this);
-                    Debugging.Assert(() => otherState != null && otherState is BlockTermState);
-                    Debugging.Assert(() => !doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
+                    if (Debugging.AssertsEnabled)
+                    {
+                        Debugging.Assert(() => otherState != null && otherState is BlockTermState);
+                        Debugging.Assert(() => !doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
+                    }
                     state.CopyFrom(otherState);
                     seekPending = true;
                     indexIsCurrent = false;
@@ -794,7 +797,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         throw new InvalidOperationException("terms index was not loaded");
                     }
 
-                    Debugging.Assert(() => ord < outerInstance.numTerms);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < outerInstance.numTerms);
 
                     // TODO: if ord is in same terms block and
                     // after current ord, we should avoid this seek just
@@ -803,7 +806,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     bool result = NextBlock();
 
                     // Block must exist since ord < numTerms:
-                    Debugging.Assert(() => result);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
 
                     indexIsCurrent = true;
                     didIndexNext = false;
@@ -811,7 +814,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     seekPending = false;
 
                     state.Ord = indexEnum.Ord - 1;
-                    Debugging.Assert(() => state.Ord >= -1, () => "Ord=" + state.Ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state.Ord >= -1, () => "Ord=" + state.Ord);
                     term.CopyBytes(indexEnum.Term);
 
                     // Now, scan:
@@ -819,9 +822,9 @@ namespace Lucene.Net.Codecs.BlockTerms
                     while (left > 0)
                     {
                         BytesRef term = _next();
-                        Debugging.Assert(() => term != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
                         left--;
-                        Debugging.Assert(() => indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexIsCurrent);
                     }
                 }
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
index 63a82a9..18eb752 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldMetaData(FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int int64sSize)
             {
-                Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
 
                 FieldInfo = fieldInfo;
                 TermsStartPointer = termsStartPointer;
@@ -123,7 +123,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         public override TermsConsumer AddField(FieldInfo field)
         {
             //System.out.println("\nBTW.addField seg=" + segment + " field=" + field.name);
-            Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             TermsIndexWriterBase.FieldWriter fieldIndexWriter = termsIndexWriter.AddField(field, m_output.GetFilePointer());
             return new TermsWriter(this, fieldIndexWriter, field, postingsWriter);
@@ -235,7 +235,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debugging.Assert(() => stats.DocFreq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0);
                 //System.out.println("BTW: finishTerm term=" + fieldInfo.name + ":" + text.utf8ToString() + " " + text + " seg=" + segment + " df=" + stats.docFreq);
 
                 bool isIndexTerm = fieldIndexWriter.CheckIndexTerm(text, stats);
@@ -302,8 +302,11 @@ namespace Lucene.Net.Codecs.BlockTerms
 
             private int SharedPrefix(BytesRef term1, BytesRef term2)
             {
-                Debugging.Assert(() => term1.Offset == 0);
-                Debugging.Assert(() => term2.Offset == 0);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => term1.Offset == 0);
+                    Debugging.Assert(() => term2.Offset == 0);
+                }
                 int pos1 = 0;
                 int pos1End = pos1 + Math.Min(term1.Length, term2.Length);
                 int pos2 = 0;
@@ -359,7 +362,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 for (int termCount = 0; termCount < pendingCount; termCount++)
                 {
                     BlockTermState state = pendingTerms[termCount].State;
-                    Debugging.Assert(() => state != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
                     bytesWriter.WriteVInt32(state.DocFreq);
                     if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                     {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
index bf5ba28..ca21abb 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         {
             this.termComp = termComp;
 
-            Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
 
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, FixedGapTermsIndexWriter.TERMS_INDEX_EXTENSION), context);
 
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // In case terms index gets loaded, later, on demand
                     totalIndexInterval = indexInterval * indexDivisor;
                 }
-                Debugging.Assert(() => totalIndexInterval > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => totalIndexInterval > 0);
 
                 SeekDir(input, dirOffset);
 
@@ -190,7 +190,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int lo = 0;          // binary search
                 int hi = fieldIndex.numIndexTerms - 1;
-                Debugging.Assert(() => outerInstance.totalIndexInterval > 0, () => "totalIndexInterval=" + outerInstance.totalIndexInterval);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.totalIndexInterval > 0, () => "totalIndexInterval=" + outerInstance.totalIndexInterval);
 
                 while (hi >= lo)
                 {
@@ -211,7 +211,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     }
                     else
                     {
-                        Debugging.Assert(() => mid >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => mid >= 0);
                         ord = mid * outerInstance.totalIndexInterval;
                         return fieldIndex.termsStart + fieldIndex.termsDictOffsets.Get(mid);
                     }
@@ -219,7 +219,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                 if (hi < 0)
                 {
-                    Debugging.Assert(() => hi == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hi == -1);
                     hi = 0;
                 }
 
@@ -252,7 +252,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int idx = (int)(ord / outerInstance.totalIndexInterval);
                 // caller must ensure ord is in bounds
-                Debugging.Assert(() => idx < fieldIndex.numIndexTerms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => idx < fieldIndex.numIndexTerms);
                 long offset = fieldIndex.termOffsets.Get(idx);
                 int length = (int)(fieldIndex.termOffsets.Get(1 + idx) - offset);
                 outerInstance.termBytesReader.FillSlice(term, fieldIndex.termBytesStart + offset, length);
@@ -328,11 +328,11 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // -1 is passed to mean "don't load term index", but
                     // if we are then later loaded it's overwritten with
                     // a real value
-                    Debugging.Assert(() => outerInstance.outerInstance.indexDivisor > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.outerInstance.indexDivisor > 0);
 
                     this.numIndexTerms = 1 + (numIndexTerms - 1) / outerInstance.outerInstance.indexDivisor;
 
-                    Debugging.Assert(() => this.numIndexTerms > 0, () => "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => this.numIndexTerms > 0, () => "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
 
                     if (outerInstance.outerInstance.indexDivisor == 1)
                     {
@@ -345,11 +345,11 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                             // records offsets into main terms dict file
                             termsDictOffsets = PackedInt32s.GetReader(clone);
-                            Debugging.Assert(() => termsDictOffsets.Count == numIndexTerms);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsDictOffsets.Count == numIndexTerms);
 
                             // records offsets into byte[] term data
                             termOffsets = PackedInt32s.GetReader(clone);
-                            Debugging.Assert(() => termOffsets.Count == 1 + numIndexTerms);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termOffsets.Count == 1 + numIndexTerms);
                         }
                         finally
                         {
@@ -398,8 +398,11 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 int numTermBytes = (int)(nextTermOffset - termOffset);
 
                                 clone.Seek(indexStart + termOffset);
-                                Debugging.Assert(() => indexStart + termOffset < clone.Length, () => "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
-                                Debugging.Assert(() => indexStart + termOffset + numTermBytes < clone.Length);
+                                if (Debugging.AssertsEnabled)
+                                {
+                                    Debugging.Assert(() => indexStart + termOffset < clone.Length, () => "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
+                                    Debugging.Assert(() => indexStart + termOffset + numTermBytes < clone.Length);
+                                }
 
                                 outerInstance.outerInstance.termBytes.Copy(clone, numTermBytes);
                                 termOffsetUpto += numTermBytes;
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
index d0f8f5d..ac25b8d 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
@@ -187,7 +187,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 lastTermsPointer = termsFilePointer;
 
                 // save term length (in bytes)
-                Debugging.Assert(() => indexedTermLength <= short.MaxValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => indexedTermLength <= short.MaxValue);
                 termLengths[numIndexTerms] = (short)indexedTermLength;
                 totTermLength += indexedTermLength;
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
index 5fcfd0e..d6caa49 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
@@ -55,7 +55,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, VariableGapTermsIndexWriter.TERMS_INDEX_EXTENSION), new IOContext(context, true));
             //this.segment = segment; // LUCENENET: Not used
             bool success = false;
-            Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
 
             try
             {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
index 5812245..db5c9a5 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
@@ -292,7 +292,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 if (text.Length == 0)
                 {
                     // We already added empty string in ctor
-                    Debugging.Assert(() => termsFilePointer == startTermsFilePointer);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => termsFilePointer == startTermsFilePointer);
                     return;
                 }
                 int lengthSave = text.Length;
diff --git a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
index c6b18d3..b2aaf1d 100644
--- a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
@@ -380,7 +380,7 @@ namespace Lucene.Net.Codecs.Bloom
                 var bloomFilter = outerInstance._bloomFilterFactory.GetSetForField(_state, field);
                 if (bloomFilter != null)
                 {
-                    Debugging.Assert(() => (_bloomFilters.ContainsKey(field) == false));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (_bloomFilters.ContainsKey(field) == false));
 
                     _bloomFilters.Add(field, bloomFilter);
                     return new WrappedTermsConsumer(_delegateFieldsConsumer.AddField(field), bloomFilter);
diff --git a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
index 5b7e804..76c007a 100644
--- a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
+++ b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
@@ -228,7 +228,7 @@ namespace Lucene.Net.Codecs.Bloom
 
         private ContainsResult MayContainValue(int positiveHash)
         {
-            Debugging.Assert(() => (positiveHash >= 0));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => (positiveHash >= 0));
 
             // Bloom sizes are always base 2 and so can be ANDed for a fast modulo
             var pos = positiveHash & _bloomSize;
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
index 400de2e..f0ce63c 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
@@ -109,7 +109,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             internal virtual void Seek(long fp, int upto)
             {
-                Debugging.Assert(() => upto < blockSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < blockSize);
                 if (seekPending || fp != lastBlockFP)
                 {
                     pendingFP = fp;
@@ -173,7 +173,7 @@ namespace Lucene.Net.Codecs.IntBlock
                         fp += indexIn.ReadVInt64();
                     }
                 }
-                Debugging.Assert(() => upto < outerInstance.m_blockSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < outerInstance.m_blockSize);
             }
 
             public override void Seek(Int32IndexInput.Reader other)
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
index feb98e0..869b93a 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    Debugging.Assert(() => upto >= lastUpto);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
index 89c956d..3c90d8c 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
@@ -118,7 +118,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 // TODO: should we do this in real-time, not lazy?
                 pendingFP = fp;
                 pendingUpto = upto;
-                Debugging.Assert(() => pendingUpto >= 0, () => "pendingUpto=" + pendingUpto);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingUpto >= 0, () => "pendingUpto=" + pendingUpto);
                 seekPending = true;
             }
 
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
index 1ef5b83..db3af9d 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override void Write(DataOutput indexOut, bool absolute)
             {
-                Debugging.Assert(() => upto >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
                 if (absolute)
                 {
                     indexOut.WriteVInt32(upto);
@@ -116,7 +116,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    Debugging.Assert(() => upto >= lastUpto);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
@@ -136,7 +136,7 @@ namespace Lucene.Net.Codecs.IntBlock
             hitExcDuringWrite = true;
             upto -= Add(v) - 1;
             hitExcDuringWrite = false;
-            Debugging.Assert(() => upto >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
         }
 
         protected override void Dispose(bool disposing)
@@ -152,7 +152,7 @@ namespace Lucene.Net.Codecs.IntBlock
                     while (upto > stuffed)
                     {
                         upto -= Add(0) - 1;
-                        Debugging.Assert(() => upto >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
                         stuffed += 1;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
index 51e8238..2d92f3f 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
@@ -372,7 +372,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                     else
                     { 
-                        Debugging.Assert(() => false);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                         return false;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
index 4cd0dda..330237a 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
@@ -552,7 +552,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        Debugging.Assert(() => length % 8 == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length % 8 == 0);
                         var bits = new long[(int)length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
index 16a0e4d..63c9a80 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
@@ -589,7 +589,7 @@ namespace Lucene.Net.Codecs.Memory
 
                             upto++;
                         }
-                        Debugging.Assert(() => upto == docFreq);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == docFreq);
                         ent = new HighFreqTerm(docs, freqs, positions, payloads, totalTermFreq);
                     }
 
@@ -625,7 +625,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                 }
                 this.skipOffsets[numTerms] = skipOffset;
-                Debugging.Assert(() => skipOffset == skipCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => skipOffset == skipCount);
             }
 
             /// <summary>Returns approximate RAM bytes used. </summary>
@@ -738,7 +738,7 @@ namespace Lucene.Net.Codecs.Memory
 
             private void FinishSkips()
             {
-                Debugging.Assert(() => count == terms.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == terms.Length);
                 int lastTermOffset = termOffsets[count - 1];
                 int lastTermLength = termOffsets[count] - lastTermOffset;
 
@@ -972,7 +972,7 @@ namespace Lucene.Net.Codecs.Memory
                 {
                     termOrd = (int) ((OrdTermState) state).Ord;
                     SetTerm();
-                    Debugging.Assert(() => term.Equals(scratch));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Equals(scratch));
                 }
 
                 public override BytesRef Term => scratch;
@@ -1207,13 +1207,16 @@ namespace Lucene.Net.Codecs.Memory
                                 while (label > states[i].transitionMax)
                                 {
                                     states[i].transitionUpto++;
-                                    Debugging.Assert(() => states[i].transitionUpto < states[i].transitions.Length);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => states[i].transitionUpto < states[i].transitions.Length);
                                     states[i].transitionMin = states[i].transitions[states[i].transitionUpto].Min;
                                     states[i].transitionMax = states[i].transitions[states[i].transitionUpto].Max;
-                                    Debugging.Assert(() => states[i].transitionMin >= 0);
-                                    Debugging.Assert(() => states[i].transitionMin <= 255);
-                                    Debugging.Assert(() => states[i].transitionMax >= 0);
-                                    Debugging.Assert(() => states[i].transitionMax <= 255);
+                                    if (Debugging.AssertsEnabled)
+                                    {
+                                        Debugging.Assert(() => states[i].transitionMin >= 0);
+                                        Debugging.Assert(() => states[i].transitionMin <= 255);
+                                        Debugging.Assert(() => states[i].transitionMax >= 0);
+                                        Debugging.Assert(() => states[i].transitionMax <= 255);
+                                    }
                                 }
 
                                 // Skip forwards until we find a term matching
@@ -1254,7 +1257,7 @@ namespace Lucene.Net.Codecs.Memory
                                         //   System.out.println("  no match; already beyond; return termOrd=" + termOrd);
                                         // }
                                         stateUpto -= skipUpto;
-                                        Debugging.Assert(() => stateUpto >= 0);
+                                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto >= 0);
                                         return;
                                     }
                                     else if (label == (outerInstance.termBytes[termOffset_i + i] & 0xFF))
@@ -1269,7 +1272,7 @@ namespace Lucene.Net.Codecs.Memory
                                             int nextState = runAutomaton.Step(states[stateUpto].state, label);
 
                                             // Automaton is required to accept startTerm:
-                                            Debugging.Assert(() => nextState != -1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextState != -1);
 
                                             stateUpto++;
                                             states[stateUpto].changeOrd = outerInstance.skips[skipOffset + skipUpto++];
@@ -1300,12 +1303,12 @@ namespace Lucene.Net.Codecs.Memory
                                             while (termOrd < outerInstance.terms.Length &&
                                                    outerInstance.Compare(termOrd, startTerm) <= 0)
                                             {
-                                                Debugging.Assert(() => termOrd == startTermOrd ||
+                                                if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd == startTermOrd ||
                                                              outerInstance.skipOffsets[termOrd] ==
                                                              outerInstance.skipOffsets[termOrd + 1]);
                                                 termOrd++;
                                             }
-                                            Debugging.Assert(() => termOrd - startTermOrd < outerInstance.minSkipCount);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd - startTermOrd < outerInstance.minSkipCount);
                                             termOrd--;
                                             stateUpto -= skipUpto;
                                             // if (DEBUG) {
@@ -1386,7 +1389,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (termOrd == 0 && outerInstance.termOffsets[1] == 0)
                     {
                         // Special-case empty string:
-                        Debugging.Assert(() => stateUpto == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto == 0);
                         // if (DEBUG) {
                         //   System.out.println("  visit empty string");
                         // }
@@ -1435,9 +1438,9 @@ namespace Lucene.Net.Codecs.Memory
                         //   System.out.println("  term=" + new BytesRef(termBytes, termOffset, termLength).utf8ToString() + " skips=" + Arrays.toString(skips));
                         // }
 
-                        Debugging.Assert(() => termOrd < state.changeOrd);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd < state.changeOrd);
 
-                        Debugging.Assert(() => stateUpto <= termLength, () => "term.length=" + termLength + "; stateUpto=" + stateUpto);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto <= termLength, () => "term.length=" + termLength + "; stateUpto=" + stateUpto);
                         int label = outerInstance.termBytes[termOffset + stateUpto] & 0xFF;
 
                         while (label > state.transitionMax)
@@ -1456,7 +1459,7 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 else
                                 {
-                                    Debugging.Assert(() => state.changeOrd > termOrd);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state.changeOrd > termOrd);
                                     // if (DEBUG) {
                                     //   System.out.println("  jumpend " + (state.changeOrd - termOrd));
                                     // }
@@ -1467,14 +1470,17 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 goto nextTermContinue;
                             }
-                            Debugging.Assert(() => state.transitionUpto < state.transitions.Length,
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.transitionUpto < state.transitions.Length,
                                 () => " state.transitionUpto=" + state.transitionUpto + " vs " + state.transitions.Length);
                             state.transitionMin = state.transitions[state.transitionUpto].Min;
                             state.transitionMax = state.transitions[state.transitionUpto].Max;
-                            Debugging.Assert(() => state.transitionMin >= 0);
-                            Debugging.Assert(() => state.transitionMin <= 255);
-                            Debugging.Assert(() => state.transitionMax >= 0);
-                            Debugging.Assert(() => state.transitionMax <= 255);
+                            if (Debugging.AssertsEnabled)
+                            {
+                                Debugging.Assert(() => state.transitionMin >= 0);
+                                Debugging.Assert(() => state.transitionMin <= 255);
+                                Debugging.Assert(() => state.transitionMax >= 0);
+                                Debugging.Assert(() => state.transitionMax <= 255);
+                            }
                         }
 
                         int targetLabel = state.transitionMin;
@@ -1603,7 +1609,7 @@ namespace Lucene.Net.Codecs.Memory
                             if (compiledAutomaton.CommonSuffixRef != null)
                             {
                                 //System.out.println("suffix " + compiledAutomaton.commonSuffixRef.utf8ToString());
-                                Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
                                 if (termLength < compiledAutomaton.CommonSuffixRef.Length)
                                 {
                                     termOrd++;
@@ -2002,7 +2008,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                         return postings[upto];
                     }
                 }
@@ -2011,7 +2017,7 @@ namespace Lucene.Net.Codecs.Memory
                     while (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                         if (liveDocs.Get(postings[upto]))
                         {
                             return postings[upto];
@@ -2186,7 +2192,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public override int NextPosition()
             {
-                Debugging.Assert(() => skipPositions > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => skipPositions > 0);
                 skipPositions--;
 
                 int pos = postings[upto++];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
index 55d733e..6d79270 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
@@ -166,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -218,7 +218,7 @@ namespace Lucene.Net.Codecs.Memory
                 this.longsSize = longsSize;
                 this.index = index;
 
-                Debugging.Assert(() => (numTerms & (~0xffffffffL)) == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (numTerms & (~0xffffffffL)) == 0);
                 int numBlocks = (int)(numTerms + INTERVAL - 1) / INTERVAL;
                 this.numSkipInfo = longsSize + 3;
                 this.skipInfo = new long[numBlocks * numSkipInfo];
@@ -500,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         var status = SeekCeil(term);
-                        Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -631,7 +631,7 @@ namespace Lucene.Net.Codecs.Memory
                 internal override void DecodeStats()
                 {
                     var arc = TopFrame().arc;
-                    Debugging.Assert(() => arc.NextFinalOutput == fstOutputs.NoOutput);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.NextFinalOutput == fstOutputs.NoOutput);
                     ord = arc.Output.Value;
                     base.DecodeStats();
                 }
@@ -699,7 +699,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
@@ -837,7 +837,7 @@ namespace Lucene.Net.Codecs.Memory
                     arc.Output = fstOutputs.Add(TopFrame().arc.Output, arc.Output);
                     term = Grow(arc.Label);
                     level++;
-                    Debugging.Assert(() => frame == stack[level]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => frame == stack[level]);
                 }
 
                 private Frame PopFrame()
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
index 93c61d1..16d2d0c 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
@@ -128,7 +128,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t1, NO_OUTPUT) || Equals(t2, NO_OUTPUT))
                 return NO_OUTPUT;
             
-            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             long[] min = t1.longs, max = t2.longs;
             int pos = 0;
@@ -183,7 +183,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             int pos = 0;
             long diff = 0;
@@ -220,7 +220,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             var pos = 0;
             var accum = new long[_longsSize];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
index 4eb4a32..e12eb5a 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
@@ -166,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -369,7 +369,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         SeekStatus status = SeekCeil(term);
-                        Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -500,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 internal override void DecodeMetaData()
                 {
-                    Debugging.Assert(() => term != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
                     if (!decoded)
                     {
                         if (meta.bytes != null)
@@ -611,7 +611,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
index b7c595c..2176e99 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
@@ -144,7 +144,7 @@ namespace Lucene.Net.Codecs.Memory
 
                     ++count;
                 }
-                Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
             }
 
             if (missing)
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
index de1b5fa..802ca19 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
@@ -675,7 +675,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        Debugging.Assert(() => length % 8 == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length % 8 == 0);
                         var bits = new long[(int) length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index 8df0e00..7fa27bf 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -146,7 +146,7 @@ namespace Lucene.Net.Codecs.Memory
                 public override void StartDoc(int docID, int termDocFreq)
                 {
                     int delta = docID - lastDocID;
-                    Debugging.Assert(() => docID == 0 || delta > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docID == 0 || delta > 0);
                     lastDocID = docID;
                     docCount++;
 
@@ -161,7 +161,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         buffer.WriteVInt32(delta << 1);
-                        Debugging.Assert(() => termDocFreq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => termDocFreq > 0);
                         buffer.WriteVInt32(termDocFreq);
                     }
 
@@ -171,12 +171,12 @@ namespace Lucene.Net.Codecs.Memory
 
                 public override void AddPosition(int pos, BytesRef payload, int startOffset, int endOffset)
                 {
-                    Debugging.Assert(() => payload == null || outerInstance.field.HasPayloads);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null || outerInstance.field.HasPayloads);
 
                     //System.out.println("      addPos pos=" + pos + " payload=" + payload);
 
                     int delta = pos - lastPos;
-                    Debugging.Assert(() => delta >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0);
                     lastPos = pos;
 
                     int payloadLen = 0;
@@ -231,7 +231,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 public virtual PostingsWriter Reset()
                 {
-                    Debugging.Assert(() => buffer.GetFilePointer() == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.GetFilePointer() == 0);
                     lastDocID = 0;
                     docCount = 0;
                     lastPayloadLen = 0;
@@ -255,9 +255,9 @@ namespace Lucene.Net.Codecs.Memory
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debugging.Assert(() => postingsWriter.docCount == stats.DocFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => postingsWriter.docCount == stats.DocFreq);
 
-                Debugging.Assert(() => buffer2.GetFilePointer() == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer2.GetFilePointer() == 0);
 
                 buffer2.WriteVInt32(stats.DocFreq);
                 if (field.IndexOptions != IndexOptions.DOCS_ONLY)
@@ -402,7 +402,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                Debugging.Assert(() => numDocs > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
                 if (buffer.Length < bufferIn.Length)
                 {
                     buffer = ArrayUtil.Grow(buffer, bufferIn.Length);
@@ -446,7 +446,7 @@ namespace Lucene.Net.Codecs.Memory
                         else
                         {
                             freq = @in.ReadVInt32();
-                            Debugging.Assert(() => freq > 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                         }
 
                         if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
@@ -555,7 +555,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsAndPositionsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                Debugging.Assert(() => numDocs > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
 
                 // System.out.println("D&P reset bytes this=" + this);
                 // for(int i=bufferIn.offset;i<bufferIn.length;i++) {
@@ -606,7 +606,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         freq = @in.ReadVInt32();
-                        Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                     }
 
                     if (liveDocs == null || liveDocs.Get(accum))
@@ -655,7 +655,7 @@ namespace Lucene.Net.Codecs.Memory
             public override int NextPosition()
             {
                 //System.out.println("    nextPos storePayloads=" + storePayloads + " this=" + this);
-                Debugging.Assert(() => posPending > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => posPending > 0);
                 posPending--;
                 if (!storePayloads)
                 {
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
index 17ed5fb..8f61c25 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Codecs.Pulsing
             int minBlockSize, int maxBlockSize) 
             : base()
         {
-            Debugging.Assert(() => minBlockSize > 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => minBlockSize > 1);
 
             _freqCutoff = freqCutoff;
             _minBlockSize = minBlockSize;
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
index d43a4f7..b7568b2 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
@@ -122,7 +122,7 @@ namespace Lucene.Net.Codecs.Pulsing
                 }
                 else
                 {
-                    Debugging.Assert(() => WrappedTermState != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => WrappedTermState != null);
                     clone.WrappedTermState = (BlockTermState)WrappedTermState.Clone();
                     clone.Absolute = Absolute;
 
@@ -172,7 +172,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var termState2 = (PulsingTermState) termState;
 
-            Debugging.Assert(() => empty.Length == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => empty.Length == 0);
 
             termState2.Absolute = termState2.Absolute || absolute;
             // if we have positions, its total TF, otherwise its computed based on docFreq.
@@ -340,7 +340,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                Debugging.Assert(() => termState.PostingsSize != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termState.PostingsSize != -1);
 
                 // Must make a copy of termState's byte[] so that if
                 // app does TermsEnum.next(), this DocsEnum is not affected
@@ -482,7 +482,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsAndPositionsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                Debugging.Assert(() => termState.PostingsSize != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termState.PostingsSize != -1);
 
                 if (_postingsBytes == null)
                 {
@@ -542,7 +542,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public override int NextPosition()
             {
-                Debugging.Assert(() => _posPending > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => _posPending > 0);
 
                 _posPending--;
 
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
index 7179fd5..f1b0ec5 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
@@ -150,7 +150,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartTerm()
         {
-            Debugging.Assert(() => _pendingCount == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount == 0);
         }
 
         // TODO: -- should we NOT reuse across fields?  would
@@ -175,7 +175,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartDoc(int docId, int termDocFreq)
         {
-            Debugging.Assert(() => docId >= 0, () => "Got DocID=" + docId);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docId >= 0, () => "Got DocID=" + docId);
 
             if (_pendingCount == _pending.Length)
             {
@@ -185,7 +185,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             if (_pendingCount != -1)
             {
-                Debugging.Assert(() => _pendingCount < _pending.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount < _pending.Length);
                 _currentDoc = _pending[_pendingCount];
                 _currentDoc.docID = docId;
                 if (_indexOptions == IndexOptions.DOCS_ONLY)
@@ -267,7 +267,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var state2 = (PulsingTermState)state;
 
-            Debugging.Assert(() => _pendingCount > 0 || _pendingCount == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount > 0 || _pendingCount == -1);
 
             if (_pendingCount == -1)
             {
@@ -318,7 +318,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         for (var posIDX = 0; posIDX < doc.termFreq; posIDX++)
                         {
                             var pos = _pending[pendingIDX++];
-                            Debugging.Assert(() => pos.docID == doc.docID);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos.docID == doc.docID);
                             var posDelta = pos.pos - lastPos;
                             lastPos = pos.pos;
 
@@ -361,7 +361,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
                             if (payloadLength > 0)
                             {
-                                Debugging.Assert(() => _storePayloads);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => _storePayloads);
                                 _buffer.WriteBytes(pos.payload.Bytes, 0, pos.payload.Length);
                             }
                         }
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         Position doc = _pending[posIdx];
                         int delta = doc.docID - lastDocId;
 
-                        Debugging.Assert(() => doc.termFreq != 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => doc.termFreq != 0);
 
                         if (doc.termFreq == 1)
                         {
@@ -411,7 +411,7 @@ namespace Lucene.Net.Codecs.Pulsing
             bool abs)
         {
             var _state = (PulsingTermState)state;
-            Debugging.Assert(() => empty.Length == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => empty.Length == 0);
             _absolute = _absolute || abs;
             if (_state.bytes == null)
             {
@@ -469,7 +469,7 @@ namespace Lucene.Net.Codecs.Pulsing
         /// </summary>
         private void Push()
         {
-            Debugging.Assert(() => _pendingCount == _pending.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount == _pending.Length);
 
             _wrappedPostingsWriter.StartTerm();
 
@@ -487,7 +487,7 @@ namespace Lucene.Net.Codecs.Pulsing
                     }
                     else if (doc.docID != pos.docID)
                     {
-                        Debugging.Assert(() => pos.docID > doc.docID);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => pos.docID > doc.docID);
                         _wrappedPostingsWriter.FinishDoc();
                         doc = pos;
                         _wrappedPostingsWriter.StartDoc(doc.docID, doc.termFreq);
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
index 5943d16..dad545a 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
@@ -263,7 +263,7 @@ namespace Lucene.Net.Codecs.Sep
         public override DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState termState,
             IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
         {
-            Debugging.Assert(() => fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
             SepTermState termState_ = (SepTermState)termState;
             SepDocsAndPositionsEnum postingsEnum;
             if (reuse == null || !(reuse is SepDocsAndPositionsEnum))
@@ -692,7 +692,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        Debugging.Assert(() => payloadLength >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payloadLength >= 0);
                     }
                     pendingPosCount--;
                     position = 0;
@@ -707,7 +707,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        Debugging.Assert(() => payloadLength >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payloadLength >= 0);
                     }
                     position += (int)(((uint)code) >> 1);
                     pendingPayloadBytes += payloadLength;
@@ -719,7 +719,7 @@ namespace Lucene.Net.Codecs.Sep
                 }
 
                 pendingPosCount--;
-                Debugging.Assert(() => pendingPosCount >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingPosCount >= 0);
                 return position;
             }
 
@@ -741,7 +741,7 @@ namespace Lucene.Net.Codecs.Sep
                     return payload;
                 }
 
-                Debugging.Assert(() => pendingPayloadBytes >= payloadLength);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingPayloadBytes >= payloadLength);
 
                 if (pendingPayloadBytes > payloadLength)
                 {
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
index 5f75ab4..e460fde 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
@@ -262,10 +262,10 @@ namespace Lucene.Net.Codecs.Sep
         /// Add a new position &amp; payload. </summary>
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
-            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
 
             int delta = position - lastPosition;
-            Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
             lastPosition = position;
 
             if (storePayloads)
@@ -317,8 +317,11 @@ namespace Lucene.Net.Codecs.Sep
         {
             SepTermState state_ = (SepTermState)state;
             // TODO: -- wasteful we are counting this in two places?
-            Debugging.Assert(() => state_.DocFreq > 0);
-            Debugging.Assert(() => state_.DocFreq == df);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => state_.DocFreq > 0);
+                Debugging.Assert(() => state_.DocFreq == df);
+            }
 
             state_.DocIndex = docOut.GetIndex();
             state_.DocIndex.CopyFrom(docIndex, false);
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
index 54528de..b7c50ef 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
@@ -195,7 +195,7 @@ namespace Lucene.Net.Codecs.Sep
         protected override int ReadSkipData(int level, IndexInput skipStream)
         {
             int delta;
-            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
             if (currentFieldStoresPayloads)
             {
                 // the current field stores payloads.
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
index 3cd61c1..2ef7094 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
@@ -178,7 +178,7 @@ namespace Lucene.Net.Codecs.Sep
             //         current payload length equals the length at the previous
             //         skip point
 
-            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
 
             if (curStorePayloads)
             {
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
index 151afe8..2123bd4 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
@@ -76,25 +76,25 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     break;
                 }
-                Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.FIELD), () => scratch.Utf8ToString());
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.FIELD), () => scratch.Utf8ToString());
                 var fieldName = StripPrefix(SimpleTextDocValuesWriter.FIELD);
                 var field = new OneField();
                 
                 fields[fieldName] = field;
 
                 ReadLine();
-                Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
 
                 var dvType = (DocValuesType)Enum.Parse(typeof(DocValuesType), StripPrefix(SimpleTextDocValuesWriter.TYPE));
-                // Debugging.Assert(() => dvType != null); // LUCENENET: Not possible for an enum to be null in .NET
+                // if (Debugging.AssertsEnabled) Debugging.Assert(() => dvType != null); // LUCENENET: Not possible for an enum to be null in .NET
                 if (dvType == DocValuesType.NUMERIC)
                 {
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MINVALUE),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MINVALUE),
                         () => "got " + scratch.Utf8ToString() + " field=" + fieldName + " ext=" + ext);
                     field.MinValue = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.MINVALUE), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (1 + field.Pattern.Length + 2)*maxDoc);
@@ -102,10 +102,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.BINARY)
                 {
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength + 2)*maxDoc);
@@ -113,16 +113,16 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.SORTED || dvType == DocValuesType.SORTED_SET)
                 {
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
                     field.NumValues = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.NUMVALUES), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     ReadLine();
-                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
                     field.OrdPattern = StripPrefix(SimpleTextDocValuesWriter.ORDPATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength)*field.NumValues +
@@ -136,16 +136,19 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // We should only be called from above if at least one
             // field has DVs:
-            Debugging.Assert(() => fields.Count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Count > 0);
         }
 
         public override NumericDocValues GetNumeric(FieldInfo fieldInfo)
         {
             var field = fields[fieldInfo.Name];
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => field != null);
 
-            // SegmentCoreReaders already verifies this field is valid:
-            Debugging.Assert(() => field != null, () => "field=" + fieldInfo.Name + " fields=" + fields);
+                // SegmentCoreReaders already verifies this field is valid:
+                Debugging.Assert(() => field != null, () => "field=" + fieldInfo.Name + " fields=" + fields);
+            }
 
             var @in = (IndexInput)data.Clone();
             var scratch = new BytesRef();
@@ -241,7 +244,7 @@ namespace Lucene.Net.Codecs.SimpleText
         public override BinaryDocValues GetBinary(FieldInfo fieldInfo)
         {
             var field = fields[fieldInfo.Name];
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -275,7 +278,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * docId);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -332,7 +335,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * index);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -365,7 +368,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var field = fields[fieldInfo.Name];
 
             // SegmentCoreReaders already verifies this field is valid:
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -434,7 +437,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
                         () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
@@ -470,7 +473,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // SegmentCoreReaders already verifies this field is
             // valid:
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
 
             var input = (IndexInput) data.Clone();
             var scratch = new BytesRef();
@@ -539,7 +542,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
                         () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
index 856baa2..e7bc522 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
@@ -69,16 +69,19 @@ namespace Lucene.Net.Codecs.SimpleText
         /// </summary>
         private bool FieldSeen(string field)
         {
-            Debugging.Assert(() => !_fieldsSeen.Contains(field), () => "field \"" + field + "\" was added more than once during flush");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !_fieldsSeen.Contains(field), () => "field \"" + field + "\" was added more than once during flush");
             _fieldsSeen.Add(field);
             return true;
         }
 
         public override void AddNumericField(FieldInfo field, IEnumerable<long?> values)
         {
-            Debugging.Assert(() => FieldSeen(field.Name));
-            Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC ||
-                         field.NormType == DocValuesType.NUMERIC);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => FieldSeen(field.Name));
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC ||
+                             field.NormType == DocValuesType.NUMERIC);
+            }
             WriteFieldEntry(field, DocValuesType.NUMERIC);
 
             // first pass to find min/max
@@ -118,26 +121,29 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 long value = n.GetValueOrDefault();
 
-                Debugging.Assert(() => value >= minValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => value >= minValue);
 
                 var delta = (decimal)value - (decimal)minValue; // LUCENENET specific - use decimal rather than BigInteger
                 string s = delta.ToString(patternString, CultureInfo.InvariantCulture);
-                Debugging.Assert(() => s.Length == patternString.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length == patternString.Length);
                 SimpleTextUtil.Write(data, s, scratch);
                 SimpleTextUtil.WriteNewline(data);
                 SimpleTextUtil.Write(data, n == null ? "F" : "T", scratch);
                 SimpleTextUtil.WriteNewline(data);
                 numDocsWritten++;
-                Debugging.Assert(() => numDocsWritten <= numDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocsWritten <= numDocs);
             }
 
-            Debugging.Assert(() => numDocs == numDocsWritten, () => "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numDocsWritten, () => "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
         }
 
         public override void AddBinaryField(FieldInfo field, IEnumerable<BytesRef> values)
         {
-            Debugging.Assert(() => FieldSeen(field.Name));
-            Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => FieldSeen(field.Name));
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
+            }
 
             var maxLength = 0;
             foreach (var value in values)
@@ -192,13 +198,16 @@ namespace Lucene.Net.Codecs.SimpleText
                 numDocsWritten++;
             }
 
-            Debugging.Assert(() => numDocs == numDocsWritten);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numDocsWritten);
         }
 
         public override void AddSortedField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<long?> docToOrd)
         {
-            Debugging.Assert(() => FieldSeen(field.Name));
-            Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => FieldSeen(field.Name));
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
+            }
             WriteFieldEntry(field, DocValuesType.SORTED);
 
             int valueCount = 0;
@@ -268,10 +277,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                Debugging.Assert(() => valuesSeen <= valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen <= valueCount);
             }
 
-            Debugging.Assert(() => valuesSeen == valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen == valueCount);
 
             foreach (var ord in docToOrd)
             {
@@ -283,8 +292,11 @@ namespace Lucene.Net.Codecs.SimpleText
         public override void AddSortedSetField(FieldInfo field, IEnumerable<BytesRef> values,
             IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
         {
-            Debugging.Assert(() => FieldSeen(field.Name));
-            Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => FieldSeen(field.Name));
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
+            }
             WriteFieldEntry(field, DocValuesType.SORTED_SET);
 
             long valueCount = 0;
@@ -375,10 +387,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                Debugging.Assert(() => valuesSeen <= valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen <= valueCount);
             }
 
-            Debugging.Assert(() => valuesSeen == valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen == valueCount);
 
             using (var ordStream = ords.GetEnumerator())
             {
@@ -426,7 +438,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var success = false;
             try
             {
-                Debugging.Assert(() => _fieldsSeen.Count > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => _fieldsSeen.Count > 0);
                 // java : sheisty to do this here?
                 SimpleTextUtil.Write(data, END);
                 SimpleTextUtil.WriteNewline(data);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
index 9c50ef3..e9a68b0 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
@@ -57,29 +57,29 @@ namespace Lucene.Net.Codecs.SimpleText
             {
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
                 var size = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMFIELDS.Length, scratch), CultureInfo.InvariantCulture);
                 var infos = new FieldInfo[size];
 
                 for (var i = 0; i < size; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
                     string name = ReadString(SimpleTextFieldInfosWriter.NAME.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
                     int fieldNumber = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMBER.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
                     bool isIndexed = Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.ISINDEXED.Length, scratch), CultureInfo.InvariantCulture);
 
                     IndexOptions indexOptions;
                     if (isIndexed)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
                         indexOptions = (IndexOptions)Enum.Parse(typeof(IndexOptions), ReadString(SimpleTextFieldInfosWriter.INDEXOPTIONS.Length,
                                 scratch));
                     }
@@ -89,46 +89,46 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
                     bool storeTermVector =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.STORETV.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
                     bool storePayloads =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.PAYLOADS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
                     bool omitNorms = !Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.NORMS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
                     string nrmType = ReadString(SimpleTextFieldInfosWriter.NORMS_TYPE.Length, scratch);
                     Index.DocValuesType normsType = DocValuesType(nrmType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
                     string dvType = ReadString(SimpleTextFieldInfosWriter.DOCVALUES.Length, scratch);
                     Index.DocValuesType docValuesType = DocValuesType(dvType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
                     long dvGen = Convert.ToInt64(ReadString(SimpleTextFieldInfosWriter.DOCVALUES_GEN.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
                     int numAtts = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUM_ATTS.Length, scratch), CultureInfo.InvariantCulture);
                     IDictionary<string, string> atts = new Dictionary<string, string>();
 
                     for (int j = 0; j < numAtts; j++)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
                         string key = ReadString(SimpleTextFieldInfosWriter.ATT_KEY.Length, scratch);
 
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
                         string value = ReadString(SimpleTextFieldInfosWriter.ATT_VALUE.Length, scratch);
                         atts[key] = value;
                     }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
index 02b8cb2..949c682 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     if (fi.IsIndexed)
                     {
-                        Debugging.Assert(() => fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         SimpleTextUtil.Write(output, INDEXOPTIONS);
                         SimpleTextUtil.Write(output, 
                             fi.IndexOptions != IndexOptions.NONE ? fi.IndexOptions.ToString() : string.Empty, 
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
index a4432a8..7e0c8d0 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
@@ -159,7 +159,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override BytesRef Next()
             {
-                //Debugging.Assert(() => !ended); // LUCENENET: Ended field is never set, so this can never fail
+                //if (Debugging.AssertsEnabled) Debugging.Assert(() => !ended); // LUCENENET: Ended field is never set, so this can never fail
                 var result = _fstEnum.Next();
 
                 if (result == null) return null;
@@ -315,7 +315,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     else
                     {
-                        Debugging.Assert(
+                        if (Debugging.AssertsEnabled) Debugging.Assert(
                             () => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                             // LUCENENET TODO: This assert fails sometimes, which in turns causes _scratch.Utf8ToString() to throw an index out of range exception
                             StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END), () => "scratch=" + _scratch.Utf8ToString());
@@ -446,7 +446,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     else
                     {
-                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                                      StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END));
 
                         if (!first && (_liveDocs == null || _liveDocs.Get(_docId)))
@@ -472,7 +472,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readPositions)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.POS.Length, _scratch.Length - SimpleTextFieldsWriter.POS.Length,
                         _scratchUtf162);
                     pos = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
@@ -485,12 +485,12 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readOffsets)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.START_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.START_OFFSET.Length, _scratchUtf162);
                     _startOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.END_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.END_OFFSET.Length, _scratchUtf162);
                     _endOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
index 91562fc..31b85d9 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
@@ -163,9 +163,12 @@ namespace Lucene.Net.Codecs.SimpleText
 
                 if (_writeOffsets)
                 {
-                    Debugging.Assert(() => endOffset >= startOffset);
-                    Debugging.Assert(() => startOffset >= _lastStartOffset,
-                        () => "startOffset=" + startOffset + " lastStartOffset=" + _lastStartOffset);
+                    if (Debugging.AssertsEnabled)
+                    {
+                        Debugging.Assert(() => endOffset >= startOffset);
+                        Debugging.Assert(() => startOffset >= _lastStartOffset,
+                            () => "startOffset=" + startOffset + " lastStartOffset=" + _lastStartOffset);
+                    }
                     _lastStartOffset = startOffset;
                     _outerInstance.Write(START_OFFSET);
                     _outerInstance.Write(Convert.ToString(startOffset, CultureInfo.InvariantCulture));
@@ -177,7 +180,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                 if (payload != null && payload.Length > 0)
                 {
-                    Debugging.Assert(() => payload.Length != 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => payload.Length != 0);
                     _outerInstance.Write(PAYLOAD);
                     _outerInstance.Write(payload);
                     _outerInstance.Newline();
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
index b7245f7..0c2c553 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override IBits ReadLiveDocs(Directory dir, SegmentCommitInfo info, IOContext context)
         {
-            Debugging.Assert(() => info.HasDeletions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => info.HasDeletions);
             var scratch = new BytesRef();
             var scratchUtf16 = new CharsRef();
 
@@ -80,7 +80,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 input = dir.OpenChecksumInput(fileName, context);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SIZE));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SIZE));
                 var size = ParseInt32At(scratch, SIZE.Length, scratchUtf16);
 
                 var bits = new BitSet(size);
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 SimpleTextUtil.ReadLine(input, scratch);
                 while (!scratch.Equals(END))
                 {
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, DOC));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, DOC));
                     var docid = ParseInt32At(scratch, DOC.Length, scratchUtf16);
                     bits.Set(docid);
                     SimpleTextUtil.ReadLine(input, scratch);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
index 8be96c1..8fdf142 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
@@ -53,43 +53,43 @@ namespace Lucene.Net.Codecs.SimpleText
             try
             {
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
                 string version = ReadString(SimpleTextSegmentInfoWriter.SI_VERSION.Length, scratch);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
                 int docCount = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_DOCCOUNT.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
                 bool isCompoundFile = Convert.ToBoolean(ReadString(SimpleTextSegmentInfoWriter.SI_USECOMPOUND.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
                 int numDiag = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_DIAG.Length, scratch), CultureInfo.InvariantCulture);
                 IDictionary<string, string> diagnostics = new Dictionary<string, string>();
 
                 for (int i = 0; i < numDiag; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
                     string key = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_KEY.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
                     string value = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_VALUE.Length, scratch);
                     diagnostics[key] = value;
                 }
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
                 int numFiles = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_FILES.Length, scratch), CultureInfo.InvariantCulture);
                 var files = new JCG.HashSet<string>();
 
                 for (int i = 0; i < numFiles; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
                     string fileName = ReadString(SimpleTextSegmentInfoWriter.SI_FILE.Length, scratch);
                     files.Add(fileName);
                 }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
index ac3e8d7..c17061f 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
@@ -113,26 +113,26 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            Debugging.Assert(() => upto == _offsets.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == _offsets.Length);
         }
 
         public override void VisitDocument(int n, StoredFieldVisitor visitor)
         {
             _input.Seek(_offsets[n]);
             ReadLine();
-            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
             var numFields = ParseInt32At(SimpleTextStoredFieldsWriter.NUM.Length);
 
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
                 int fieldNumber = ParseInt32At(SimpleTextStoredFieldsWriter.FIELD.Length);
                 FieldInfo fieldInfo = _fieldInfos.FieldInfo(fieldNumber);
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
 
                 BytesRef type;
                 if (EqualsAt(SimpleTextStoredFieldsWriter.TYPE_STRING, _scratch, SimpleTextStoredFieldsWriter.TYPE.Length))
@@ -171,7 +171,7 @@ namespace Lucene.Net.Codecs.SimpleText
                         break;
                     case StoredFieldVisitor.Status.NO:
                         ReadLine();
-                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
                         break;
                     case StoredFieldVisitor.Status.STOP:
                         return;
@@ -182,7 +182,7 @@ namespace Lucene.Net.Codecs.SimpleText
         private void ReadField(BytesRef type, FieldInfo fieldInfo, StoredFieldVisitor visitor)
         {
             ReadLine();
-            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
             if (Equals(type, SimpleTextStoredFieldsWriter.TYPE_STRING))
             {
                 visitor.StringField(fieldInfo,
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
index 95abd7f..71f23ab 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
@@ -109,7 +109,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            Debugging.Assert(() => upto == _offsets.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == _offsets.Length);
         }
 
         public override Fields Get(int doc)
@@ -119,7 +119,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             _input.Seek(_offsets[doc]);
             ReadLine();
-            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
             var numFields = ParseInt32At(SimpleTextTermVectorsWriter.NUMFIELDS.Length);
             if (numFields == 0)
             {
@@ -128,28 +128,28 @@ namespace Lucene.Net.Codecs.SimpleText
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
                 // skip fieldNumber:
                 ParseInt32At(SimpleTextTermVectorsWriter.FIELD.Length);
 
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
                 var fieldName = ReadString(SimpleTextTermVectorsWriter.FIELDNAME.Length, _scratch);
 
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
                 var positions = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPOSITIONS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
                 var offsets = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDOFFSETS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
                 var payloads = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPAYLOADS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
                 var termCount = ParseInt32At(SimpleTextTermVectorsWriter.FIELDTERMCOUNT.Length);
 
                 var terms = new SimpleTVTerms(offsets, positions, payloads);
@@ -158,7 +158,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 for (var j = 0; j < termCount; j++)
                 {
                     ReadLine();
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
                     var term = new BytesRef();
                     var termLength = _scratch.Length - SimpleTextTermVectorsWriter.TERMTEXT.Length;
                     term.Grow(termLength);
@@ -169,7 +169,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     terms.terms.Add(term, postings);
 
                     ReadLine();
-                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
                     postings.freq = ParseInt32At(SimpleTextTermVectorsWriter.TERMFREQ.Length);
 
                     if (!positions && !offsets) continue;
@@ -194,12 +194,12 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (positions)
                         {
                             ReadLine();
-                            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
                             postings.positions[k] = ParseInt32At(SimpleTextTermVectorsWriter.POSITION.Length);
                             if (payloads)
                             {
                                 ReadLine();
-                                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
                                 if (_scratch.Length - SimpleTextTermVectorsWriter.PAYLOAD.Length == 0)
                                 {
                                     postings.payloads[k] = null;
@@ -217,11 +217,11 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (!offsets) continue;
 
                         ReadLine();
-                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
                         postings.startOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.STARTOFFSET.Length);
 
                         ReadLine();
-                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
                         postings.endOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.ENDOFFSET.Length);
                     }
                 }
@@ -444,7 +444,7 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 get
                 {
-                    Debugging.Assert(() => _freqRenamed != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _freqRenamed != -1);
                     return _freqRenamed;
                 }
             }
@@ -495,7 +495,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     if (_positions != null)
                         return _positions.Length;
 
-                    Debugging.Assert(() => _startOffsets != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _startOffsets != null);
                     return _startOffsets.Length;
                 }
             }
@@ -540,7 +540,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override int NextPosition()
             {
-                Debugging.Assert(() => (_positions != null && _nextPos < _positions.Length) ||
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (_positions != null && _nextPos < _positions.Length) ||
                     _startOffsets != null && _nextPos < _startOffsets.Length);
 
                 if (_positions != null)
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
index 011029e..b2dd7ef 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
@@ -143,7 +143,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            Debugging.Assert(() => _positions || _offsets);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => _positions || _offsets);
 
             if (_positions)
             {
@@ -156,7 +156,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     Write(PAYLOAD);
                     if (payload != null)
                     {
-                        Debugging.Assert(() => payload.Length > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payload.Length > 0);
                         Write(payload);
                     }
                     NewLine();
diff --git a/src/Lucene.Net.Expressions/ExpressionComparator.cs b/src/Lucene.Net.Expressions/ExpressionComparator.cs
index e187adf..4905386 100644
--- a/src/Lucene.Net.Expressions/ExpressionComparator.cs
+++ b/src/Lucene.Net.Expressions/ExpressionComparator.cs
@@ -49,11 +49,11 @@ namespace Lucene.Net.Expressions
             base.SetScorer(scorer);
             // TODO: might be cleaner to lazy-init 'source' and set scorer after?
 
-            Debugging.Assert(() => readerContext != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => readerContext != null);
             try
             {
                 var context = new Dictionary<string, object>();
-                Debugging.Assert(() => scorer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => scorer != null);
                 context["scorer"] = scorer;
                 scores = source.GetValues(context, readerContext);
             }
diff --git a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
index dd1b052..a42d4ec 100644
--- a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
+++ b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Expressions
         {
             try
             {
-                Debugging.Assert(() => document == scorer.DocID);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => document == scorer.DocID);
                 return scorer.GetScore();
             }
             catch (IOException exception)
diff --git a/src/Lucene.Net.Facet/DrillDownQuery.cs b/src/Lucene.Net.Facet/DrillDownQuery.cs
index 65e9c52..7d26a0e 100644
--- a/src/Lucene.Net.Facet/DrillDownQuery.cs
+++ b/src/Lucene.Net.Facet/DrillDownQuery.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Facet
             {
                 throw new ArgumentException("cannot apply filter unless baseQuery isn't null; pass ConstantScoreQuery instead");
             }
-            Debugging.Assert(() => clauses.Length == 1 + other.drillDownDims.Count, () => clauses.Length + " vs " + (1 + other.drillDownDims.Count));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => clauses.Length == 1 + other.drillDownDims.Count, () => clauses.Length + " vs " + (1 + other.drillDownDims.Count));
             drillDownDims.PutAll(other.drillDownDims);
             query.Add(new FilteredQuery(clauses[0].Query, filter), Occur.MUST);
             for (int i = 1; i < clauses.Length; i++)
diff --git a/src/Lucene.Net.Facet/DrillSideways.cs b/src/Lucene.Net.Facet/DrillSideways.cs
index 65d4c10..b144bb2 100644
--- a/src/Lucene.Net.Facet/DrillSideways.cs
+++ b/src/Lucene.Net.Facet/DrillSideways.cs
@@ -175,7 +175,7 @@ namespace Lucene.Net.Facet
             }
             else
             {
-                Debugging.Assert(() => clauses.Length == 1 + drillDownDims.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => clauses.Length == 1 + drillDownDims.Count);
                 baseQuery = clauses[0].Query;
                 startClause = 1;
             }
diff --git a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
index 23ed7d6..ccbc0c2 100644
--- a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
+++ b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
@@ -89,7 +89,7 @@ namespace Lucene.Net.Facet
             // TODO: if we ever allow null baseScorer ... it will
             // mean we DO score docs out of order ... hmm, or if we
             // change up the order of the conjuntions below
-            Debugging.Assert(() => baseScorer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => baseScorer != null);
 
             // some scorers, eg ReqExlScorer, can hit NPE if cost is called after nextDoc
             long baseQueryCost = baseScorer.GetCost();
@@ -395,7 +395,7 @@ namespace Lucene.Net.Facet
                 while (slot0 < CHUNK && (slot0 = seen.NextSetBit(slot0)) != -1)
                 {
                     int ddDocID = docIDs[slot0];
-                    Debugging.Assert(() => ddDocID != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ddDocID != -1);
 
                     int baseDocID = baseScorer.DocID;
                     if (baseDocID < ddDocID)
@@ -550,7 +550,7 @@ namespace Lucene.Net.Facet
                     //}
 
                     // Mark slot as valid:
-                    Debugging.Assert(() => docIDs[slot] != docID, () => "slot=" + slot + " docID=" + docID);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docIDs[slot] != docID, () => "slot=" + slot + " docID=" + docID);
                     docIDs[slot] = docID;
                     scores[slot] = baseScorer.GetScore();
                     filledSlots[filledCount++] = slot;
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index 2f5610c..b0f0f0e 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -694,7 +694,7 @@ namespace Lucene.Net.Facet
                 }
             }
             parts.Add(new string(buffer, 0, upto));
-            Debugging.Assert(() => !lastEscape);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !lastEscape);
             return parts.ToArray();
         }
     }
diff --git a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
index fa124e8..0641fc6 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else
                 {
-                    Debugging.Assert(() => flags == 2);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => flags == 2);
                     // This point is only the end of an interval; attach
                     // it to last interval:
                     elementaryIntervals.Add(new InclusiveRange(prev, v));
@@ -275,7 +275,7 @@ namespace Lucene.Net.Facet.Range
 
             public InclusiveRange(long start, long end)
             {
-                Debugging.Assert(() => end >= start);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= start);
                 this.Start = start;
                 this.End = end;
             }
@@ -349,7 +349,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else if (left != null)
                 {
-                    Debugging.Assert(() => right != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right != null);
                     // Recurse:
                     left.AddOutputs(index, range);
                     right.AddOutputs(index, range);
@@ -361,7 +361,7 @@ namespace Lucene.Net.Facet.Range
                 Indent(sb, depth);
                 if (left == null)
                 {
-                    Debugging.Assert(() => right == null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right == null);
                     sb.Append("leaf: " + start + " to " + end);
                 }
                 else
@@ -377,7 +377,7 @@ namespace Lucene.Net.Facet.Range
 
                 if (left != null)
                 {
-                    Debugging.Assert(() => right != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right != null);
                     left.ToString(sb, depth + 1);
                     right.ToString(sb, depth + 1);
                 }
diff --git a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
index 9033c19..92f5d57 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            Debugging.Assert(() => prefixLen > 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLen > 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
@@ -75,7 +75,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public CategoryPath(params string[] components)
         {
-            Debugging.Assert(() => components.Length > 0, () => "use CategoryPath.EMPTY to create an empty path");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => components.Length > 0, () => "use CategoryPath.EMPTY to create an empty path");
             foreach (string comp in components)
             {
                 if (string.IsNullOrEmpty(comp))
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index d9846c8..52df74c 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -190,7 +190,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             // verify (to some extent) that merge policy in effect would preserve category docids 
             if (indexWriter != null)
             {
-                Debugging.Assert(() => !(indexWriter.Config.MergePolicy is TieredMergePolicy), () => "for preserving category docids, merging none-adjacent segments is not allowed");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !(indexWriter.Config.MergePolicy is TieredMergePolicy), () => "for preserving category docids, merging none-adjacent segments is not allowed");
             }
 
             // after we opened the writer, and the index is locked, it's safe to check
@@ -826,7 +826,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
                                 FacetLabel cp = new FacetLabel(FacetsConfig.StringToPath(t.Utf8ToString()));
                                 docsEnum = termsEnum.Docs(null, docsEnum, DocsFlags.NONE);
                                 bool res = cache.Put(cp, docsEnum.NextDoc() + ctx.DocBase);
-                                Debugging.Assert(() => !res, () => "entries should not have been evicted from the cache");
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => !res, () => "entries should not have been evicted from the cache");
                             }
                             else
                             {
@@ -907,7 +907,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             }
 
             int[] parents = GetTaxoArrays().Parents;
-            Debugging.Assert(() => ordinal < parents.Length, () => "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ordinal < parents.Length, () => "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
             return parents[ordinal];
         }
 
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
index 10170b9..52e71c9 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
@@ -77,7 +77,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         public TaxonomyIndexArrays(IndexReader reader, TaxonomyIndexArrays copyFrom)
         {
-            Debugging.Assert(() => copyFrom != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => copyFrom != null);
 
             // note that copyParents.length may be equal to reader.maxDoc(). this is not a bug
             // it may be caused if e.g. the taxonomy segments were merged, and so an updated
diff --git a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
index 3c8aaa1..c9bc017 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            Debugging.Assert(() => prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
index ca0976d..b71ed1f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 if (ft.IsHierarchical && ft.IsMultiValued == false)
                 {
                     int dimRootOrd = m_taxoReader.GetOrdinal(new FacetLabel(dim));
-                    Debugging.Assert(() => dimRootOrd > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => dimRootOrd > 0);
                     m_values[dimRootOrd] += Rollup(m_children[dimRootOrd]);
                 }
             }
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
index de702f8..fa4cec5 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
@@ -143,7 +143,7 @@ namespace Lucene.Net.Facet.Taxonomy
         public static T OpenIfChanged<T>(T oldTaxoReader) where T : TaxonomyReader
         {
             T newTaxoReader = (T)oldTaxoReader.DoOpenIfChanged();
-            Debugging.Assert(() => newTaxoReader != oldTaxoReader);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => newTaxoReader != oldTaxoReader);
             return newTaxoReader;
         }
 
diff --git a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
index fbc983a..2e39fef 100644
--- a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
@@ -248,7 +248,7 @@ namespace Lucene.Net.Search.Grouping
                     bottomGroup = m_orderedGroups.Last();
                     m_orderedGroups.Remove(bottomGroup);
                 }
-                Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
 
                 groupMap.Remove(bottomGroup.GroupValue);
 
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search.Grouping
 
                 groupMap[bottomGroup.GroupValue] = bottomGroup;
                 m_orderedGroups.Add(bottomGroup);
-                Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
 
                 int lastComparerSlot = m_orderedGroups.Last().ComparerSlot;
                 foreach (FieldComparer fc in comparers)
@@ -315,7 +315,7 @@ namespace Lucene.Net.Search.Grouping
                     prevLast = m_orderedGroups.Last();
                     m_orderedGroups.Remove(group);
                 }
-                Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
             }
             else
             {
@@ -333,7 +333,7 @@ namespace Lucene.Net.Search.Grouping
             if (m_orderedGroups != null)
             {
                 m_orderedGroups.Add(group);
-                Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
                 var newLast = m_orderedGroups.Last();
                 // If we changed the value of the last group, or changed which group was last, then update bottom:
                 if (group == newLast || prevLast != newLast)
@@ -376,7 +376,7 @@ namespace Lucene.Net.Search.Grouping
             var comparer = new BuildSortedSetComparer(this);
             m_orderedGroups = new JCG.SortedSet<CollectedSearchGroup<TGroupValue>>(comparer);
             m_orderedGroups.UnionWith(groupMap.Values);
-            Debugging.Assert(() => m_orderedGroups.Count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count > 0);
 
             foreach (FieldComparer fc in comparers)
             {
diff --git a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
index c5e14e8..2934754 100644
--- a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
@@ -153,8 +153,11 @@ namespace Lucene.Net.Search.Grouping
             {
 
                 //System.out.println("    ltcheck");
-                Debugging.Assert(() => group1 != group2);
-                Debugging.Assert(() => group1.comparerSlot != group2.comparerSlot);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => group1 != group2);
+                    Debugging.Assert(() => group1.comparerSlot != group2.comparerSlot);
+                }
 
                 int numComparers = outerInstance.comparers.Length;
                 for (int compIDX = 0; compIDX < numComparers; compIDX++)
@@ -221,7 +224,7 @@ namespace Lucene.Net.Search.Grouping
                 {
                     // Replace bottom element in PQ and then updateTop
                     OneGroup og = groupQueue.Top;
-                    Debugging.Assert(() => og != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => og != null);
                     og.count = subDocUpto;
                     og.topGroupDoc = docBase + topGroupDoc;
                     // Swap pending docs
@@ -521,7 +524,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 if (subDocUpto == 1)
                 {
-                    Debugging.Assert(() => !queueFull);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !queueFull);
 
                     //System.out.println("    init copy to bottomSlot=" + bottomSlot);
                     foreach (FieldComparer fc in comparers)
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index 540bdd5..32f4756 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -106,12 +106,12 @@ namespace Lucene.Net.Search.Grouping
             {
                 this.shardIndex = shardIndex;
                 iter = shard.GetEnumerator();
-                //Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
+                //if (Debugging.AssertsEnabled) Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
             }
 
             public ISearchGroup<T> Next()
             {
-                //Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
+                //if (Debugging.AssertsEnabled) Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
                 ISearchGroup<T> group = iter.Current;
                 if (group.SortValues == null)
                 {
@@ -186,12 +186,12 @@ namespace Lucene.Net.Search.Grouping
                 {
                     if (groupValue == null)
                     {
-                        Debugging.Assert(() => otherMergedGroup.groupValue != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => otherMergedGroup.groupValue != null);
                     }
                     else
                     {
                         
-                        Debugging.Assert(() => !groupValueIsValueType 
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !groupValueIsValueType 
                             ? JCG.EqualityComparer<T>.Default.Equals(groupValue, otherMergedGroup.groupValue)
 
                             // LUCENENET specific - use J2N.Collections.StructuralEqualityComparer.Default.Equals() if we have a reference type
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 // We never have another MergedGroup instance with
                 // same groupValue
-                Debugging.Assert(() => NeverEquals(other));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => NeverEquals(other));
 
                 if (other is MergedGroup<T> otherMergedGroup)
                 {
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search.Grouping
                 }
 
                 // Tie break by min shard index:
-                Debugging.Assert(() => group.MinShardIndex != other.MinShardIndex);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => group.MinShardIndex != other.MinShardIndex);
                 return group.MinShardIndex - other.MinShardIndex;
             }
         }
@@ -327,7 +327,7 @@ namespace Lucene.Net.Search.Grouping
                         //System.out.println("      new");
                         mergedGroup = new MergedGroup<T>(group.GroupValue);
                         mergedGroup.MinShardIndex = shard.ShardIndex;
-                        Debugging.Assert(() => group.SortValues != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => group.SortValues != null);
                         mergedGroup.TopValues = group.SortValues;
                         groupsSeen[group.GroupValue] = mergedGroup;
                         mergedGroup.IsInQueue = true;
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index 5b4ddbd..2d65424 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -175,7 +175,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     BytesRef facetEndPrefix = BytesRef.DeepCopyOf(m_facetPrefix);
                     facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
                     m_endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
-                    Debugging.Assert(() => m_endFacetOrd < 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => m_endFacetOrd < 0);
                     m_endFacetOrd = -m_endFacetOrd - 1; // Points to the ord one higher than facetEndPrefix
                 }
                 else
@@ -203,7 +203,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     this.m_mergePos = startFacetOrd == -1 ? 1 : startFacetOrd + 1;
                     if (m_mergePos < m_maxTermPos)
                     {
-                        Debugging.Assert(() => tenum != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => tenum != null);
                         tenum.SeekExact(startFacetOrd == -1 ? 0 : startFacetOrd);
                         m_mergeTerm = tenum.Term;
                     }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
index 37ed392..ffc4b8e 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
@@ -292,7 +292,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    Debugging.Assert(() => currentStartOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentStartOffset >= 0);
                     return currentStartOffset;
                 }
             }
@@ -301,7 +301,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    Debugging.Assert(() => currentEndOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentEndOffset >= 0);
                     return currentEndOffset;
                 }
             }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
index 920c9d1..22805b2 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
         internal void AddMatch(int startOffset, int endOffset, BytesRef term)
         {
-            Debugging.Assert(() => startOffset >= this.startOffset && startOffset <= this.endOffset);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= this.startOffset && startOffset <= this.endOffset);
             if (numMatches == matchStarts.Length)
             {
                 int newLength = ArrayUtil.Oversize(numMatches + 1, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 matchEnds = newMatchEnds;
                 matchTerms = newMatchTerms;
             }
-            Debugging.Assert(() => matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
             matchStarts[numMatches] = startOffset;
             matchEnds[numMatches] = endOffset;
             matchTerms[numMatches] = term;
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
index 7244c75..b5b5a8a 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
@@ -542,7 +542,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 AtomicReaderContext subContext = leaves[leaf];
                 AtomicReader r = subContext.AtomicReader;
 
-                Debugging.Assert(() => leaf >= lastLeaf); // increasing order
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => leaf >= lastLeaf); // increasing order
 
                 // if the segment has changed, we must initialize new enums.
                 if (leaf != lastLeaf)
@@ -671,7 +671,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 // LUCENE-5166: this hit would span the content limit... however more valid 
                 // hits may exist (they are sorted by start). so we pretend like we never 
                 // saw this term, it won't cause a passage to be added to passageQueue or anything.
-                Debugging.Assert(() => EMPTY.StartOffset == int.MaxValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => EMPTY.StartOffset == int.MaxValue);
                 if (start < contentLength && end > contentLength)
                 {
                     continue;
@@ -714,7 +714,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                         return passages;
                     }
                     // advance breakiterator
-                    Debugging.Assert(() => BreakIterator.Done < 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => BreakIterator.Done < 0);
                     current.startOffset = Math.Max(bi.Preceding(start + 1), 0);
                     current.endOffset = Math.Min(bi.Next(), contentLength);
                 }
@@ -727,7 +727,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                     {
                         // multitermquery match, pull from payload
                         term = off.dp.GetPayload();
-                        Debugging.Assert(() => term != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
                     }
                     current.AddMatch(start, end, term);
                     if (off.pos == dp.Freq)
@@ -751,7 +751,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             }
 
             // Dead code but compiler disagrees:
-            Debugging.Assert(() => false);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
             return null;
         }
 
@@ -766,7 +766,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             // BreakIterator should be un-next'd:
             List<Passage> passages = new List<Passage>();
             int pos = bi.Current;
-            Debugging.Assert(() => pos == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos == 0);
             while (passages.Count < maxPassages)
             {
                 int next = bi.Next();
@@ -883,7 +883,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public LimitedStoredFieldVisitor(string[] fields, char[] valueSeparators, int maxLength)
             {
-                Debugging.Assert(() => fields.Length == valueSeparators.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == valueSeparators.Length);
                 this.fields = fields;
                 this.valueSeparators = valueSeparators;
                 this.maxLength = maxLength;
@@ -896,7 +896,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public override void StringField(Index.FieldInfo fieldInfo, string value)
             {
-                Debugging.Assert(() => currentField >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField >= 0);
                 StringBuilder builder = builders[currentField];
                 if (builder.Length > 0 && builder.Length < maxLength)
                 {
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
index 60f133f..7f656b8 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
@@ -142,7 +142,7 @@ namespace Lucene.Net.Search.VectorHighlight
             {
                 this.iter = iter;
                 T removeTop = RemoveTop();
-                Debugging.Assert(() => removeTop == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => removeTop == null);
             }
 
             public T Top()
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
index 1b5798d..9818598 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Search.VectorHighlight
                 TermInfo current = termList[i];
                 if (current.Position == currentPos)
                 {
-                    Debugging.Assert(() => previous != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => previous != null);
                     previous.SetNext(current);
                     previous = current;
                     //iterator.Remove();
diff --git a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
index 02974b5..09d424a 100644
--- a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
@@ -246,7 +246,7 @@ namespace Lucene.Net.Join
                         }
                     }
 
-                    Debugging.Assert(() => _childDoc < _parentDoc, () => "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _childDoc < _parentDoc, () => "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
                     _childDoc++;
                     if (_acceptDocs != null && !_acceptDocs.Get(_childDoc))
                     {
@@ -280,7 +280,7 @@ namespace Lucene.Net.Join
 
             public override int Advance(int childTarget)
             {
-                Debugging.Assert(() => childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
 
                 //System.out.println("Q.advance childTarget=" + childTarget);
                 if (childTarget == NO_MORE_DOCS)
@@ -289,14 +289,14 @@ namespace Lucene.Net.Join
                     return _childDoc = _parentDoc = NO_MORE_DOCS;
                 }
 
-                Debugging.Assert(() => _childDoc == -1 || childTarget != _parentDoc, () => "childTarget=" + childTarget);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => _childDoc == -1 || childTarget != _parentDoc, () => "childTarget=" + childTarget);
                 if (_childDoc == -1 || childTarget > _parentDoc)
                 {
                     // Advance to new parent:
                     _parentDoc = _parentScorer.Advance(childTarget);
                     ValidateParentDoc();
                     //System.out.println("  advance to parentDoc=" + parentDoc);
-                    Debugging.Assert(() => _parentDoc > childTarget);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _parentDoc > childTarget);
                     if (_parentDoc == NO_MORE_DOCS)
                     {
                         //System.out.println("  END");
@@ -312,7 +312,7 @@ namespace Lucene.Net.Join
                     childTarget = Math.Max(childTarget, firstChild);
                 }
 
-                Debugging.Assert(() => childTarget < _parentDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => childTarget < _parentDoc);
 
                 // Advance within children of current parent:
                 _childDoc = childTarget;
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
index 9cd5bee..71deac5 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
@@ -284,7 +284,7 @@ namespace Lucene.Net.Join
                     og.counts[scorerIDX] = joinScorer.ChildCount;
                     //System.out.println("    count=" + og.counts[scorerIDX]);
                     og.docs[scorerIDX] = joinScorer.SwapChildDocs(og.docs[scorerIDX]);
-                    Debugging.Assert(() => og.docs[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => og.docs[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     //System.out.println("    len=" + og.docs[scorerIDX].length);
                     /*
                       for(int idx=0;idx<og.counts[scorerIDX];idx++) {
@@ -295,7 +295,7 @@ namespace Lucene.Net.Join
                     {
                         //System.out.println("    copy scores");
                         og.scores[scorerIDX] = joinScorer.SwapChildScores(og.scores[scorerIDX]);
-                        Debugging.Assert(() => og.scores[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => og.scores[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     }
                 }
                 else
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
index 01df4a5..84f41fd 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
@@ -284,7 +284,7 @@ namespace Lucene.Net.Join
                     }
 
                     //System.out.println("  parentDoc=" + parentDoc);
-                    Debugging.Assert(() => _parentDoc != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _parentDoc != -1);
 
                     //System.out.println("  nextChildDoc=" + nextChildDoc);
                     if (_acceptDocs != null && !_acceptDocs.Get(_parentDoc))
@@ -402,7 +402,7 @@ namespace Lucene.Net.Join
                 _prevParentDoc = _parentBits.PrevSetBit(parentTarget - 1);
 
                 //System.out.println("  rolled back to prevParentDoc=" + prevParentDoc + " vs parentDoc=" + parentDoc);
-                Debugging.Assert(() => _prevParentDoc >= _parentDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => _prevParentDoc >= _parentDoc);
                 if (_prevParentDoc > _nextChildDoc)
                 {
                     _nextChildDoc = _childScorer.Advance(_prevParentDoc);
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index d1a97ee..c6ef1a5 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -250,7 +250,7 @@ namespace Lucene.Net.Index.Memory
                             return mid;
                         }
                     }
-                    Debugging.Assert(() => comparer.Compare(bytesRef, b) != 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => comparer.Compare(bytesRef, b) != 0);
                     return -(low + 1);
                 }
 
@@ -285,7 +285,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(long ord)
                 {
-                    Debugging.Assert(() => ord < info.terms.Count);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < info.terms.Count);
                     termUpto = (int)ord;
                 }
 
@@ -332,7 +332,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(BytesRef term, TermState state)
                 {
-                    Debugging.Assert(() => state != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
                     this.SeekExact(((OrdTermState)state).Ord);
                 }
 
@@ -450,8 +450,11 @@ namespace Lucene.Net.Index.Memory
 
                 public override int NextPosition()
                 {
-                    Debugging.Assert(() => posUpto++ < freq);
-                    Debugging.Assert(() => !sliceReader.IsEndOfSlice, () => " stores offsets : " + startOffset);
+                    if (Debugging.AssertsEnabled)
+                    {
+                        Debugging.Assert(() => posUpto++ < freq);
+                        Debugging.Assert(() => !sliceReader.IsEndOfSlice, () => " stores offsets : " + startOffset);
+                    }
                     if (outerInstance.outerInstance.storeOffsets)
                     {
                         int pos = sliceReader.ReadInt32();
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index f38d804..18df8c9 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -217,7 +217,7 @@ namespace Lucene.Net.Index.Memory
             this.bytesUsed = Counter.NewCounter();
             int maxBufferedByteBlocks = (int)((maxReusedBytes / 2) / ByteBlockPool.BYTE_BLOCK_SIZE);
             int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32));
-            Debugging.Assert(() => (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
             byteBlockPool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, maxBufferedByteBlocks, bytesUsed));
             intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT32_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
             postingsWriter = new Int32BlockPool.SliceWriter(intBlockPool);
@@ -739,9 +739,12 @@ namespace Lucene.Net.Index.Memory
                 start = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 end = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 freq = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
-                Debugging.Assert(() => start.Length >= ord.Length);
-                Debugging.Assert(() => end.Length >= ord.Length);
-                Debugging.Assert(() => freq.Length >= ord.Length);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => start.Length >= ord.Length);
+                    Debugging.Assert(() => end.Length >= ord.Length);
+                    Debugging.Assert(() => freq.Length >= ord.Length);
+                }
                 return ord;
             }
 
@@ -754,9 +757,12 @@ namespace Lucene.Net.Index.Memory
                     end = ArrayUtil.Grow(end, ord.Length);
                     freq = ArrayUtil.Grow(freq, ord.Length);
                 }
-                Debugging.Assert(() => start.Length >= ord.Length);
-                Debugging.Assert(() => end.Length >= ord.Length);
-                Debugging.Assert(() => freq.Length >= ord.Length);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => start.Length >= ord.Length);
+                    Debugging.Assert(() => end.Length >= ord.Length);
+                    Debugging.Assert(() => freq.Length >= ord.Length);
+                }
                 return ord;
             }
 
diff --git a/src/Lucene.Net.Misc/Document/LazyDocument.cs b/src/Lucene.Net.Misc/Document/LazyDocument.cs
index 72baf7a..bc2aa77 100644
--- a/src/Lucene.Net.Misc/Document/LazyDocument.cs
+++ b/src/Lucene.Net.Misc/Document/LazyDocument.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Documents
             fields.TryGetValue(fieldNum, out lazyValues);
             IIndexableField[] realValues = d.GetFields(name);
 
-            Debugging.Assert(() => realValues.Length <= lazyValues.Count,
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => realValues.Length <= lazyValues.Count,
                 () => "More lazy values then real values for field: " + name);
 
             for (int i = 0; i < lazyValues.Count; i++)
@@ -164,8 +164,11 @@ namespace Lucene.Net.Documents
                 {
                     outerInstance.FetchRealValues(name, fieldNum);
                 }
-                Debugging.Assert(() => HasBeenLoaded, () => "field value was not lazy loaded");
-                Debugging.Assert(() => realValue.Name.Equals(Name, StringComparison.Ordinal), () => "realvalue name != name: " + realValue.Name + " != " + Name);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => HasBeenLoaded, () => "field value was not lazy loaded");
+                    Debugging.Assert(() => realValue.Name.Equals(Name, StringComparison.Ordinal), () => "realvalue name != name: " + realValue.Name + " != " + Name);
+                }
 
                 return realValue;
             }
diff --git a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
index 1b85aa0..17695f7 100644
--- a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
@@ -297,7 +297,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    Debugging.Assert(() => oldLiveDocs != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => oldLiveDocs != null);
                     // this loop is a little bit ineffective, as Bits has no nextSetBit():
                     for (int i = 0; i < maxDoc; i++)
                     {
diff --git a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
index 6377c8c..8f96af9 100644
--- a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    Debugging.Assert(() => oldLiveDocs != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => oldLiveDocs != null);
                     DocIdSetIterator it = bits.GetIterator();
                     for (int i = it.NextDoc(); i < maxDoc; i = it.NextDoc())
                     {
diff --git a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
index b812d2a..cfff119 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
@@ -83,8 +83,11 @@ namespace Lucene.Net.Index.Sorter
             {
                 int newID = docMap.OldToNew(i);
                 int oldID = docMap.NewToOld(newID);
-                Debugging.Assert(() => newID >= 0 && newID < maxDoc, () => "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
-                Debugging.Assert(() => i == oldID, () => "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => newID >= 0 && newID < maxDoc, () => "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
+                    Debugging.Assert(() => i == oldID, () => "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
+                }
                 if (i != oldID || newID < 0 || newID >= maxDoc)
                 {
                     return false;
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 0ff309e..6374533 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -761,7 +761,7 @@ namespace Lucene.Net.Index.Sorter
             {
                 throw new ArgumentException("reader.MaxDoc should be equal to docMap.Count, got" + reader.MaxDoc + " != " + docMap.Count);
             }
-            Debugging.Assert(() => Sorter.IsConsistent(docMap));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Sorter.IsConsistent(docMap));
             return new SortingAtomicReader(reader, docMap);
         }
 
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index 58719d3..7028244 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -134,7 +134,7 @@ namespace Lucene.Net.Index.Sorter
                 {
                     return base.GetDocMap(mergeState);
                 }
-                Debugging.Assert(() => mergeState.DocMaps.Length == 1); // we returned a singleton reader
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => mergeState.DocMaps.Length == 1); // we returned a singleton reader
                 MonotonicAppendingInt64Buffer deletes = GetDeletes(unsortedReaders);
                 return new DocMapAnonymousInnerClassHelper(this, mergeState, deletes);
             }
diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
index 91dc58b..03da23b 100644
--- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            Debugging.Assert(() => !(prefix is IList));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !(prefix is IList));
             if (!(output is IList))
             {
                 return outputs.Add((T)prefix, (T)output);
@@ -107,7 +107,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            Debugging.Assert(() => !(output is IList));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !(output is IList));
             outputs.Write((T)output, @out);
         }
 
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index d6ca39f..40b4361 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -70,8 +70,11 @@ namespace Lucene.Net.Util.Fst
             {
                 this.first = first;
                 this.second = second;
-                Debugging.Assert(() => first >= 0);
-                Debugging.Assert(() => second >= 0);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => first >= 0);
+                    Debugging.Assert(() => second >= 0);
+                }
             }
 
             public override string ToString()
@@ -134,8 +137,11 @@ namespace Lucene.Net.Util.Fst
 
         public override object Common(object output1, object output2)
         {
-            Debugging.Assert(() => Valid(output1, false));
-            Debugging.Assert(() => Valid(output2, false));
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => Valid(output1, false));
+                Debugging.Assert(() => Valid(output2, false));
+            }
             long? output1_ = (long?)output1;
             long? output2_ = (long?)output2;
             if (output1_ == NO_OUTPUT || output2_ == NO_OUTPUT)
@@ -144,8 +150,11 @@ namespace Lucene.Net.Util.Fst
             }
             else if (doShare)
             {
-                Debugging.Assert(() => output1_ > 0);
-                Debugging.Assert(() => output2_ > 0);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => output1_ > 0);
+                    Debugging.Assert(() => output2_ > 0);
+                }
                 return Math.Min(output1_.GetValueOrDefault(), output2_.GetValueOrDefault());
             }
             else if (output1_.Equals(output2_))
@@ -160,11 +169,14 @@ namespace Lucene.Net.Util.Fst
 
         public override object Subtract(object output, object inc)
         {
-            Debugging.Assert(() => Valid(output, false));
-            Debugging.Assert(() => Valid(inc, false));
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => Valid(output, false));
+                Debugging.Assert(() => Valid(inc, false));
+            }
             long? output2 = (long?)output;
             long? inc2 = (long?)inc;
-            Debugging.Assert(() => output2 >= inc2);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => output2 >= inc2);
 
             if (inc2 == NO_OUTPUT)
             {
@@ -182,8 +194,8 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            Debugging.Assert(() => Valid(prefix, false));
-            Debugging.Assert(() => Valid(output, true));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(prefix, false));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(output, true));
             long? prefix2 = (long?)prefix;
             if (output is long?)
             {
@@ -211,7 +223,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            Debugging.Assert(() => Valid(output, true));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(output, true));
             if (output is long?)
             {
                 long? output2 = (long?)output;
@@ -286,8 +298,11 @@ namespace Lucene.Net.Util.Fst
         [MethodImpl(MethodImplOptions.NoInlining)]
         public override object Merge(object first, object second)
         {
-            Debugging.Assert(() => Valid(first, false));
-            Debugging.Assert(() => Valid(second, false));
+            if (Debugging.AssertsEnabled)
+            {
+                Debugging.Assert(() => Valid(first, false));
+                Debugging.Assert(() => Valid(second, false));
+            }
             return new TwoInt64s(((long?)first).GetValueOrDefault(), ((long?)second).GetValueOrDefault());
         }
     }
diff --git a/src/Lucene.Net.Queries/BooleanFilter.cs b/src/Lucene.Net.Queries/BooleanFilter.cs
index 00744e1..d15cee8 100644
--- a/src/Lucene.Net.Queries/BooleanFilter.cs
+++ b/src/Lucene.Net.Queries/BooleanFilter.cs
@@ -78,7 +78,7 @@ namespace Lucene.Net.Queries
                 {
                     if (res == null)
                     {
-                        Debugging.Assert(() => !hasShouldClauses);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !hasShouldClauses);
                         res = new FixedBitSet(reader.MaxDoc);
                         res.Set(0, reader.MaxDoc); // NOTE: may set bits on deleted docs
                     }
diff --git a/src/Lucene.Net.Queries/CommonTermsQuery.cs b/src/Lucene.Net.Queries/CommonTermsQuery.cs
index db42ad7..e78ce71 100644
--- a/src/Lucene.Net.Queries/CommonTermsQuery.cs
+++ b/src/Lucene.Net.Queries/CommonTermsQuery.cs
@@ -279,7 +279,7 @@ namespace Lucene.Net.Queries
                         continue;
                     }
                     termsEnum = terms.GetIterator(termsEnum);
-                    Debugging.Assert(() => termsEnum != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
 
                     if (termsEnum == TermsEnum.EMPTY)
                     {
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
index ea7d844..f4d4c5f 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
@@ -182,7 +182,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                     {
                         bool hasNext;
                         hasNext = buffer.IncrementToken();
-                        Debugging.Assert(() => hasNext == true);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
                         term = termAtt.ToString();
                     }
 #pragma warning disable 168
@@ -213,7 +213,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    Debugging.Assert(() => hasNext == true);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -240,7 +240,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    Debugging.Assert(() => hasNext == true);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -307,7 +307,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                             try
                             {
                                 bool hasNext = buffer.IncrementToken();
-                                Debugging.Assert(() => hasNext == true);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
                                 term = termAtt.ToString();
                                 if (posIncrAtt != null)
                                 {
@@ -379,7 +379,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         try
                         {
                             bool hasNext = buffer.IncrementToken();
-                            Debugging.Assert(() => hasNext == true);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
                             term = termAtt.ToString();
 
                             if (posIncrAtt != null)
diff --git a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
index 1be5270..009ad62 100644
--- a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
@@ -242,7 +242,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumeSubQuery(State state)
         {
-            Debugging.Assert(() => (m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => (m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
             int start = ++state.Index;
             int precedence = 1;
             bool escaped = false;
@@ -315,7 +315,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumePhrase(State state)
         {
-            Debugging.Assert(() => (m_flags & Operator.PHRASE_OPERATOR) != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => (m_flags & Operator.PHRASE_OPERATOR) != 0);
             int start = ++state.Index;
             int copied = 0;
             bool escaped = false;
diff --git a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
index 4c9be8f..eddc6f0 100644
--- a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
@@ -187,7 +187,7 @@ namespace Lucene.Net.Replicator
         /// <exception cref="IOException"></exception>
         public virtual Stream Open(string source, string fileName)
         {
-            Debugging.Assert(() => source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
             IndexCommit commit = source.Equals(INDEX_SOURCE, StringComparison.Ordinal) ? indexCommit : taxonomyCommit;
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
diff --git a/src/Lucene.Net.Replicator/IndexRevision.cs b/src/Lucene.Net.Replicator/IndexRevision.cs
index e8895a7..3a97ead 100644
--- a/src/Lucene.Net.Replicator/IndexRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexRevision.cs
@@ -134,7 +134,7 @@ namespace Lucene.Net.Replicator
 
         public virtual Stream Open(string source, string fileName)
         {
-            Debugging.Assert(() => source.Equals(SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected={0} got={1}", SOURCE, source));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => source.Equals(SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected={0} got={1}", SOURCE, source));
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
 
diff --git a/src/Lucene.Net.Replicator/ReplicationClient.cs b/src/Lucene.Net.Replicator/ReplicationClient.cs
index f958f52..35251e6 100644
--- a/src/Lucene.Net.Replicator/ReplicationClient.cs
+++ b/src/Lucene.Net.Replicator/ReplicationClient.cs
@@ -370,7 +370,7 @@ namespace Lucene.Net.Replicator
                 // make sure to preserve revisionFiles order
                 List<RevisionFile> res = new List<RevisionFile>();
                 string source = e.Key;
-                Debugging.Assert(() => newRevisionFiles.ContainsKey(source), () => string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => newRevisionFiles.ContainsKey(source), () => string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
                 foreach (RevisionFile file in newRevisionFiles[source])
                 {
                     if (!handlerFiles.Contains(file.FileName))
@@ -416,7 +416,7 @@ namespace Lucene.Net.Replicator
             updateThread = new ReplicationThread(intervalMillis, threadName, DoUpdate, HandleUpdateException, updateLock);
             updateThread.Start();
             // we rely on isAlive to return true in isUpdateThreadAlive, assert to be on the safe side
-            Debugging.Assert(() => updateThread.IsAlive, () => "updateThread started but not alive?");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => updateThread.IsAlive, () => "updateThread started but not alive?");
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
index 0a9c457..265e06f 100644
--- a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
@@ -191,7 +191,7 @@ namespace Lucene.Net.Sandbox.Queries
                         case Selector.MIDDLE_MAX: return new MiddleMaxValue(randomOrds);
                         case Selector.MIN:
                         default:
-                            Debugging.Assert(() => false);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                             return null;
                     }
                 }
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
index cfe132c..3e5da90 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
@@ -113,7 +113,7 @@ namespace Lucene.Net.Spatial.Prefix
             protected virtual void CollectDocs(FixedBitSet bitSet)
             {
                 //WARN: keep this specialization in sync
-                Debugging.Assert(() => m_termsEnum != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_termsEnum != null);
                 m_docsEnum = m_termsEnum.Docs(m_acceptDocs, m_docsEnum, DocsFlags.NONE);
                 int docid;
                 while ((docid = m_docsEnum.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
index 1eb27b7..033eb93 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Spatial.Prefix
             : base(queryShape, fieldName, grid, detailLevel)
         {
             this.m_prefixGridScanLevel = Math.Max(0, Math.Min(prefixGridScanLevel, grid.MaxLevels - 1));
-            Debugging.Assert(() => detailLevel <= grid.MaxLevels);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => detailLevel <= grid.MaxLevels);
         }
 
         public override bool Equals(object o)
@@ -135,7 +135,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             public virtual DocIdSet GetDocIdSet()
             {
-                Debugging.Assert(() => curVNode == null, () => "Called more than once?");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => curVNode == null, () => "Called more than once?");
                 if (m_termsEnum == null)
                 {
                     return null;
@@ -169,7 +169,7 @@ namespace Lucene.Net.Spatial.Prefix
                         // LUCENENET IMPORTANT: Must not call this inline with Debug.Assert
                         // because the compiler removes Debug.Assert statements in release mode!!
                         bool hasNext = curVNode.children.MoveNext();
-                        Debugging.Assert(() => hasNext);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext);
 
                         curVNode = curVNode.children.Current;
                     }
@@ -206,7 +206,7 @@ namespace Lucene.Net.Spatial.Prefix
                     if (compare > 0)
                     {
                         // leap frog (termsEnum is beyond where we would otherwise seek)
-                        Debugging.Assert(() => !m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), () => "should be absent");
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), () => "should be absent");
                     }
                     else
                     {
@@ -250,7 +250,7 @@ namespace Lucene.Net.Spatial.Prefix
             /// <exception cref="IOException"></exception>
             private void AddIntersectingChildren()
             {
-                Debugging.Assert(() => thisTerm != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => thisTerm != null);
                 Cell cell = curVNode.cell;
                 if (cell.Level >= m_outerInstance.m_detailLevel)
                 {
@@ -261,7 +261,7 @@ namespace Lucene.Net.Spatial.Prefix
                 {
                     //If the next indexed term just adds a leaf marker ('+') to cell,
                     // then add all of those docs
-                    Debugging.Assert(() => StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
                     scanCell = m_outerInstance.m_grid.GetCell(thisTerm.Bytes, thisTerm.Offset, thisTerm.Length, scanCell);
                     if (scanCell.Level == cell.Level && scanCell.IsLeaf)
                     {
@@ -372,7 +372,7 @@ namespace Lucene.Net.Spatial.Prefix
 
                 public bool MoveNext()
                 {
-                    //Debugging.Assert(cellIter.Current != null);
+                    //if (Debugging.AssertsEnabled) Debugging.Assert(cellIter.Current != null);
 
                     // LUCENENET NOTE: The consumer of this class calls
                     // cellIter.MoveNext() before it is instantiated.
@@ -490,9 +490,9 @@ namespace Lucene.Net.Spatial.Prefix
 
             internal virtual void Reset(Cell cell)
             {
-                Debugging.Assert(() => cell != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => cell != null);
                 this.cell = cell;
-                Debugging.Assert(() => children == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => children == null);
             }
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
index 8464ec9..80d2039 100644
--- a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Spatial.Prefix
                 if (cell.Level != 0 && ((cell.ShapeRel == SpatialRelation.NOT_SET || cell.ShapeRel == SpatialRelation.WITHIN)))
                 {
                     subCellsFilter = null;
-                    Debugging.Assert(() => cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
                 }
                 ICollection<Cell> subCells = cell.GetSubCells(subCellsFilter);
                 foreach (Cell subCell in subCells)
@@ -147,7 +147,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private bool SeekExact(Cell cell)
             {
-                Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
                 this.termBytes.Bytes = cell.GetTokenBytes();
                 this.termBytes.Length = this.termBytes.Bytes.Length;
                 if (m_termsEnum == null)
@@ -157,7 +157,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private SmallDocSet GetDocs(Cell cell, IBits acceptContains)
             {
-                Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
                 return this.CollectDocs(acceptContains);
             }
 
@@ -165,8 +165,11 @@ namespace Lucene.Net.Spatial.Prefix
 
             private SmallDocSet GetLeafDocs(Cell leafCell, IBits acceptContains)
             {
-                Debugging.Assert(() => new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
-                Debugging.Assert(() => !leafCell.Equals(lastLeaf));//don't call for same leaf again
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
+                    Debugging.Assert(() => !leafCell.Equals(lastLeaf));//don't call for same leaf again
+                }
                 lastLeaf = leafCell;
 
                 if (m_termsEnum == null)
@@ -298,7 +301,7 @@ namespace Lucene.Net.Spatial.Prefix
                     }
                     docs[d++] = v;
                 }
-                Debugging.Assert(() => d == intSet.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => d == intSet.Count);
                 int size = d;
                 //sort them
                 Array.Sort(docs, 0, size);
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
index 004be33..e4fcc52 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
@@ -104,7 +104,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public virtual void Reset(byte[] bytes, int off, int len)
         {
-            Debugging.Assert(() => Level != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Level != 0);
             token = null;
             m_shapeRel = SpatialRelation.NOT_SET;
             this.bytes = bytes;
@@ -139,7 +139,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
         /// <summary>Note: not supported at level 0.</summary>
         public virtual void SetLeaf()
         {
-            Debugging.Assert(() => Level != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => Level != 0);
             m_leaf = true;
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
index 4d39985..b6b76f4 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
@@ -171,7 +171,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            Debugging.Assert(() => str.Length == level);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
@@ -197,7 +197,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            Debugging.Assert(() => str.Length == level);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
index 34d923d..36a45f3 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
@@ -48,7 +48,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public SpatialPrefixTree(SpatialContext ctx, int maxLevels)
         {
-            Debugging.Assert(() => maxLevels > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => maxLevels > 0);
             this.m_ctx = ctx;
             this.m_maxLevels = maxLevels;
         }
@@ -269,7 +269,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
                 return new ReadOnlyCollection<Cell>(new[] { cell });
             }
             string endToken = cell.TokenString;
-            Debugging.Assert(() => endToken.Length == detailLevel);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => endToken.Length == detailLevel);
             IList<Cell> cells = new List<Cell>(detailLevel);
             for (int i = 1; i < detailLevel; i++)
             {
diff --git a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
index daf619c..5b33da7 100644
--- a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
@@ -203,8 +203,11 @@ namespace Lucene.Net.Spatial.Prefix
             protected internal override void VisitLeaf(Cell cell)
             {
                 //visitRelation is declared as a field, populated by visit() so we don't recompute it
-                Debugging.Assert(() => m_outerInstance.m_detailLevel != cell.Level);
-                Debugging.Assert(() => visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => m_outerInstance.m_detailLevel != cell.Level);
+                    Debugging.Assert(() => visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
+                }
                 if (AllCellsIntersectQuery(cell, visitRelation))
                 {
                     CollectDocs(inside);
diff --git a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
index 35270a8..391f23e 100644
--- a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
+++ b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
@@ -104,7 +104,7 @@ namespace Lucene.Net.Spatial.Vector
                 // make sure it has minX and area
                 if (validX.Get(doc))
                 {
-                    Debugging.Assert(() => validY.Get(doc));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => validY.Get(doc));
                     return calculator.Distance(outerInstance.from, ptX.Get(doc), ptY.Get(doc)) * outerInstance.multiplier;
                 }
                 return nullValue;
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index f8d6c75..0be20a5 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -270,7 +270,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 IList<Transition> newTransitions = new List<Transition>();
                 foreach (Transition t in state.GetTransitions())
                 {
-                    Debugging.Assert(() => t.Min == t.Max);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => t.Min == t.Max);
                     if (t.Min == TokenStreamToAutomaton.POS_SEP)
                     {
                         if (preserveSep)
@@ -359,8 +359,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 // Next by cost:
                 long aCost = readerA.ReadInt32();
                 long bCost = readerB.ReadInt32();
-                Debugging.Assert(() => DecodeWeight(aCost) >= 0);
-                Debugging.Assert(() => DecodeWeight(bCost) >= 0);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => DecodeWeight(aCost) >= 0);
+                    Debugging.Assert(() => DecodeWeight(bCost) >= 0);
+                }
                 if (aCost < bCost)
                 {
                     return -1;
@@ -487,7 +490,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             output.WriteBytes(surfaceForm.Bytes, surfaceForm.Offset, surfaceForm.Length);
                         }
 
-                        Debugging.Assert(() => output.Position == requiredLength, () => output.Position + " vs " + requiredLength);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => output.Position == requiredLength, () => output.Position + " vs " + requiredLength);
 
                         writer.Write(buffer, 0, output.Position);
                     }
@@ -661,7 +664,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         break;
                     }
                 }
-                Debugging.Assert(() => sepIndex != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sepIndex != -1);
                 spare.Grow(sepIndex);
 
                 int payloadLen = output2.Length - sepIndex - 1;
@@ -707,7 +710,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         public override IList<LookupResult> DoLookup(string key, IEnumerable<BytesRef> contexts, bool onlyMorePopular, int num)
         {
-            Debugging.Assert(() => num > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => num > 0);
 
             if (onlyMorePopular)
             {
@@ -799,7 +802,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     }
 
                     var completions = searcher.Search();
-                    Debugging.Assert(() => completions.IsComplete);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
 
                     // NOTE: this is rather inefficient: we enumerate
                     // every matching "exactly the same analyzed form"
@@ -842,7 +845,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
 
                 var completions2 = searcher2.Search();
-                Debugging.Assert(() => completions2.IsComplete);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => completions2.IsComplete);
 
                 foreach (Util.Fst.Util.Result<PairOutputs<long?, BytesRef>.Pair> completion in completions2)
                 {
@@ -920,7 +923,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         // We found exact match, which means we should
                         // have already found it in the first search:
-                        Debugging.Assert(() => results.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => results.Count == 1);
                         return false;
                     }
                     else
@@ -964,7 +967,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             ReplaceSep(automaton);
             automaton = ConvertAutomaton(automaton);
 
-            Debugging.Assert(() => SpecialOperations.IsFinite(automaton));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => SpecialOperations.IsFinite(automaton));
 
             // Get all paths from the automaton (there can be
             // more than one path, eg if the analyzer created a
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
index d20b446..a0c70e4 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
@@ -145,7 +145,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         {
 
             BinaryDocValues textDV = MultiDocValues.GetBinaryValues(searcher.IndexReader, TEXT_FIELD_NAME);
-            Debugging.Assert(() => textDV != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => textDV != null);
 
             // This will just be null if app didn't pass payloads to build():
             // TODO: maybe just stored fields?  they compress...
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index a676d8e..fbb56ad 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// </summary>
         public static IList<Path<T>> IntersectPrefixPaths<T>(Automaton a, FST<T> fst)
         {
-            Debugging.Assert(() => a.IsDeterministic);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => a.IsDeterministic);
             IList<Path<T>> queue = new List<Path<T>>();
             List<Path<T>> endNodes = new List<Path<T>>();
             queue.Add(new Path<T>(a.GetInitialState(), fst.GetFirstArc(new FST.Arc<T>()), fst.Outputs.NoOutput, new Int32sRef()));
@@ -120,8 +120,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         FST.Arc<T> nextArc = Lucene.Net.Util.Fst.Util.ReadCeilArc(min, fst, path.FstNode, scratchArc, fstReader);
                         while (nextArc != null && nextArc.Label <= max)
                         {
-                            Debugging.Assert(() => nextArc.Label <= max);
-                            Debugging.Assert(() => nextArc.Label >= min, () => nextArc.Label + " " + min);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc.Label <= max);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc.Label >= min, () => nextArc.Label + " " + min);
                             Int32sRef newInput = new Int32sRef(currentInput.Length + 1);
                             newInput.CopyInt32s(currentInput);
                             newInput.Int32s[currentInput.Length] = nextArc.Label;
@@ -130,7 +130,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                               .CopyFrom(nextArc), fst.Outputs.Add(path.Output, nextArc.Output), newInput));
                             int label = nextArc.Label; // used in assert
                             nextArc = nextArc.IsLast ? null : fst.ReadNextRealArc(nextArc, fstReader);
-                            Debugging.Assert(() => nextArc == null || label < nextArc.Label, () => "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc == null || label < nextArc.Label, () => "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
                         }
                     }
                 }
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index c53d8c0..2b79029 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -556,7 +556,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     // a separate dedicated att for this?
                     int gramCount = posLenAtt.PositionLength;
 
-                    Debugging.Assert(() => gramCount <= grams);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => gramCount <= grams);
 
                     // Safety: make sure the recalculated count "agrees":
                     if (CountGrams(tokenBytes) != gramCount)
@@ -682,7 +682,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             BytesRef context = new BytesRef(token.Bytes, token.Offset, i);
                             long? output = Lucene.Net.Util.Fst.Util.Get(fst, Lucene.Net.Util.Fst.Util.ToInt32sRef(context, new Int32sRef()));
-                            Debugging.Assert(() => output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => output != null);
                             contextCount = DecodeWeight(output);
                             lastTokenFragment = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                             break;
@@ -699,7 +699,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         finalLastToken = BytesRef.DeepCopyOf(lastTokenFragment);
                     }
-                    Debugging.Assert(() => finalLastToken.Offset == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => finalLastToken.Offset == 0);
 
                     CharsRef spare = new CharsRef();
 
@@ -726,7 +726,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         searcher.AddStartPaths(arc, prefixOutput, true, new Int32sRef());
 
                         completions = searcher.Search();
-                        Debugging.Assert(() => completions.IsComplete);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
                     }
                     catch (IOException bogus)
                     {
@@ -754,7 +754,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             if (token.Bytes[token.Offset + i] == separator)
                             {
-                                Debugging.Assert(() => token.Length - i - 1 > 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => token.Length - i - 1 > 0);
                                 lastToken = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                                 break;
                             }
@@ -772,7 +772,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             // return numbers that are greater than long.MaxValue, which results in a negative long number.
                             (long)(long.MaxValue * (decimal)backoff * ((decimal)DecodeWeight(completion.Output)) / contextCount));
                         results.Add(result);
-                        Debugging.Assert(() => results.Count == seen.Count);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => results.Count == seen.Count);
                     //System.out.println("  add result=" + result);
                     nextCompletionContinue:;
                     }
@@ -874,7 +874,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         //private long decodeWeight(Pair<Long,BytesRef> output) {
         private static long DecodeWeight(long? output)
         {
-            Debugging.Assert(() => output != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => output != null);
             return (int)(long.MaxValue - output); // LUCENENET TODO: Perhaps a Java Lucene bug? Why cast to int when returning long?
         }
 
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
index 4455dfa..8f909db 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
@@ -115,7 +115,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         m_input.End();
                         endState = CaptureState();
                         int finalEndOffset = offsetAtt.EndOffset;
-                        Debugging.Assert(() => finalEndOffset >= endOffset);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => finalEndOffset >= endOffset);
                         if (finalEndOffset > endOffset)
                         {
                             // OK there was a token separator after the
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
index d9d974d..afdfc8d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -407,7 +407,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 output.Bytes = ArrayUtil.Grow(output.Bytes);
             }
-            Debugging.Assert(() => output.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => output.Offset == 0);
             output.Bytes[output.Length++] = (byte) arc.Label;
             FST.BytesReader fstReader = automaton.GetBytesReader();
             automaton.ReadFirstTargetArc(arc, arc, fstReader);
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index ad27c56..8efcd39 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 throw new ArgumentException("this suggester doesn't support contexts");
             }
-            Debugging.Assert(() => num > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => num > 0);
 
             if (onlyMorePopular)
             {
@@ -190,7 +190,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             try
             {
                 completions = Lucene.Net.Util.Fst.Util.ShortestPaths(fst, arc, prefixOutput, weightComparer, num, !exactFirst);
-                Debugging.Assert(() => completions.IsComplete);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
             }
             catch (IOException bogus)
             {
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         private long? LookupPrefix(BytesRef scratch, FST.Arc<long?> arc) //Bogus
         {
-            Debugging.Assert(() => 0 == (long)fst.Outputs.NoOutput);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => 0 == (long)fst.Outputs.NoOutput);
             long output = 0;
             var bytesReader = fst.GetBytesReader();
 
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search.Suggest.Fst
                 : base(source)
             {
                 this.outerInstance = outerInstance;
-                Debugging.Assert(() => source.HasPayloads == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => source.HasPayloads == false);
             }
 
             protected internal override void Encode(OfflineSorter.ByteSequencesWriter writer, ByteArrayDataOutput output, byte[] buffer, BytesRef spare, BytesRef payload, ICollection<BytesRef> contexts, long weight)
diff --git a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
index b2c32d9..4b8791f 100644
--- a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search.Suggest
         {
             get
             {
-                Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
                 return m_freqs[currentOrd];
             }
         }
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasPayloads && m_curPos < m_payloads.Length)
                 {
-                    Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
                     return m_payloads.Get(payloadSpare, currentOrd);
                 }
                 return null;
@@ -96,7 +96,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasContexts && m_curPos < m_contextSets.Count)
                 {
-                    Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
                     return m_contextSets[currentOrd];
                 }
                 return null;
diff --git a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
index 67d081e..f20029b 100644
--- a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
@@ -78,7 +78,7 @@ namespace Lucene.Net.Analysis
 
             public virtual AttributeSource.State NextState()
             {
-                Debugging.Assert(() => NextRead < InputTokens.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => NextRead < InputTokens.Count);
                 return InputTokens[NextRead++];
             }
         }
@@ -141,7 +141,7 @@ namespace Lucene.Net.Analysis
                 m_positions.Get(m_inputPos).Add(CaptureState());
                 tokenPending = false;
             }
-            Debugging.Assert(() => !insertPending);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !insertPending);
             insertPending = true;
         }
 
@@ -184,8 +184,8 @@ namespace Lucene.Net.Analysis
             {
                 Console.WriteLine("LTF.peekToken inputPos=" + m_inputPos + " outputPos=" + m_outputPos + " tokenPending=" + tokenPending);
             }
-            Debugging.Assert(() => !m_end);
-            Debugging.Assert(() => m_inputPos == -1 || m_outputPos <= m_inputPos);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !m_end);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_inputPos == -1 || m_outputPos <= m_inputPos);
             if (tokenPending)
             {
                 m_positions.Get(m_inputPos).Add(CaptureState());
@@ -199,7 +199,7 @@ namespace Lucene.Net.Analysis
             if (gotToken)
             {
                 m_inputPos += m_posIncAtt.PositionIncrement;
-                Debugging.Assert(() => m_inputPos >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_inputPos >= 0);
                 if (DEBUG)
                 {
                     Console.WriteLine("  now inputPos=" + m_inputPos);
@@ -216,7 +216,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    Debugging.Assert(() => startPosData.StartOffset == startOffset, () => "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startPosData.StartOffset == startOffset, () => "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
                 }
 
                 int endOffset = m_offsetAtt.EndOffset;
@@ -227,7 +227,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    Debugging.Assert(() => endPosData.EndOffset == endOffset, () => "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endPosData.EndOffset == endOffset, () => "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
                 }
 
                 tokenPending = true;
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            Debugging.Assert(InsertedTokenConsistent);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent);
                             insertPending = false;
                             return true;
                         }
@@ -340,7 +340,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            Debugging.Assert(InsertedTokenConsistent);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent);
                             insertPending = false;
                             return true;
                         }
@@ -364,8 +364,8 @@ namespace Lucene.Net.Analysis
         {
             int posLen = m_posLenAtt.PositionLength;
             Position endPosData = m_positions.Get(m_outputPos + posLen);
-            Debugging.Assert(() => endPosData.EndOffset != -1);
-            Debugging.Assert(() => m_offsetAtt.EndOffset == endPosData.EndOffset, () => "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => endPosData.EndOffset != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_offsetAtt.EndOffset == endPosData.EndOffset, () => "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
             return true;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
index 5f15220..0b377d1 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
@@ -112,7 +112,7 @@ namespace Lucene.Net.Analysis
                 ret = currentOff;
             }
 
-            Debugging.Assert(() => ret >= 0, () => "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ret >= 0, () => "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
             return ret;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
index 51e9e52..49bbebf 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis
         {
             excAtChar = charUpto;
             // You should only call this on init!:
-            Debugging.Assert(() => 0 == readSoFar);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => 0 == readSoFar);
         }
 
         public virtual void ThrowExcNext()
@@ -91,10 +91,10 @@ namespace Lucene.Net.Analysis
             if (excAtChar != -1)
             {
                 int left = excAtChar - readSoFar;
-                Debugging.Assert(() => left != 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => left != 0);
                 read = input.Read(cbuf, off, Math.Min(realLen, left));
                 //Characters are left
-                Debugging.Assert(() => read != 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => read != 0);
                 readSoFar += read;
             }
             else
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
index f2c076a..50152f6 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Analysis
 
         public sealed override bool IncrementToken()
         {
-            Debugging.Assert(() => !enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), () => "IncrementToken() called while in wrong state: " + streamState);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), () => "IncrementToken() called while in wrong state: " + streamState);
             ClearAttributes();
             for (; ; )
             {
@@ -219,7 +219,7 @@ namespace Lucene.Net.Analysis
             }
             else
             {
-                Debugging.Assert(() => !char.IsLowSurrogate((char)ch), () => "unpaired low surrogate: " + ch.ToString("x"));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !char.IsLowSurrogate((char)ch), () => "unpaired low surrogate: " + ch.ToString("x"));
                 off++;
                 if (char.IsHighSurrogate((char)ch))
                 {
@@ -227,12 +227,12 @@ namespace Lucene.Net.Analysis
                     if (ch2 >= 0)
                     {
                         off++;
-                        Debugging.Assert(() => char.IsLowSurrogate((char)ch2), () => "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => char.IsLowSurrogate((char)ch2), () => "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
                         return Character.ToCodePoint((char)ch, (char)ch2);
                     }
                     else
                     {
-                        Debugging.Assert(() => false, () => "stream ends with unpaired high surrogate: " + ch.ToString("x"));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "stream ends with unpaired high surrogate: " + ch.ToString("x"));
                     }
                 }
                 return ch;
@@ -300,7 +300,7 @@ namespace Lucene.Net.Analysis
             state = runAutomaton.InitialState;
             lastOffset = off = 0;
             bufferedCodePoint = -1;
-            Debugging.Assert(() => !enableChecks || streamState != State.RESET, () => "Double Reset()");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState != State.RESET, () => "Double Reset()");
             streamState = State.RESET;
         }
 
@@ -312,14 +312,14 @@ namespace Lucene.Net.Analysis
                 // in some exceptional cases (e.g. TestIndexWriterExceptions) a test can prematurely close()
                 // these tests should disable this check, by default we check the normal workflow.
                 // TODO: investigate the CachingTokenFilter "double-close"... for now we ignore this
-                Debugging.Assert(() => !enableChecks || streamState == State.END || streamState == State.CLOSE, () => "Dispose() called in wrong state: " + streamState);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.END || streamState == State.CLOSE, () => "Dispose() called in wrong state: " + streamState);
                 streamState = State.CLOSE;
             }
         }
 
         internal override bool SetReaderTestPoint()
         {
-            Debugging.Assert(() => !enableChecks || streamState == State.CLOSE, () => "SetReader() called in wrong state: " + streamState);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.CLOSE, () => "SetReader() called in wrong state: " + streamState);
             streamState = State.SETREADER;
             return true;
         }
@@ -333,7 +333,7 @@ namespace Lucene.Net.Analysis
             // these tests should disable this check (in general you should consume the entire stream)
             try
             {
-                Debugging.Assert(() => !enableChecks || streamState == State.INCREMENT_FALSE, () => "End() called before IncrementToken() returned false!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.INCREMENT_FALSE, () => "End() called before IncrementToken() returned false!");
             }
             finally
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
index 6cad1fc..486a980 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
@@ -40,15 +40,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer FieldsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.FieldsConsumer(state);
-            Debugging.Assert(() => consumer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
             return new AssertingDocValuesConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer FieldsProducer(SegmentReadState state)
         {
-            Debugging.Assert(() => state.FieldInfos.HasDocValues);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.FieldInfos.HasDocValues);
             DocValuesProducer producer = @in.FieldsProducer(state);
-            Debugging.Assert(() => producer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
 
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     count++;
                 }
-                Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddNumericField(field, values);
             }
@@ -80,10 +80,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (BytesRef b in values)
                 {
-                    Debugging.Assert(() => b == null || b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b == null || b.IsValid());
                     count++;
                 }
-                Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddBinaryField(field, values);
             }
@@ -94,25 +94,25 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    Debugging.Assert(() => b != null);
-                    Debugging.Assert(() => b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b.IsValid());
                     if (valueCount > 0)
                     {
-                        Debugging.Assert(() => b.CompareTo(lastValue) > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
                 }
-                Debugging.Assert(() => valueCount <= maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount <= maxDoc);
 
                 FixedBitSet seenOrds = new FixedBitSet(valueCount);
 
                 int count = 0;
                 foreach (long? v in docToOrd)
                 {
-                    Debugging.Assert(() => v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
                     int ord = (int)v.Value;
-                    Debugging.Assert(() => ord >= -1 && ord < valueCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= -1 && ord < valueCount);
                     if (ord >= 0)
                     {
                         seenOrds.Set(ord);
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Asserting
                     count++;
                 }
 
-                Debugging.Assert(() => count == maxDoc);
-                Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
                 CheckIterator(values.GetEnumerator(), valueCount, false);
                 CheckIterator(docToOrd.GetEnumerator(), maxDoc, false);
                 @in.AddSortedField(field, values, docToOrd);
@@ -133,11 +133,11 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    Debugging.Assert(() => b != null);
-                    Debugging.Assert(() => b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b.IsValid());
                     if (valueCount > 0)
                     {
-                        Debugging.Assert(() => b.CompareTo(lastValue) > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
@@ -150,9 +150,9 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     foreach (long? v in docToOrdCount)
                     {
-                        Debugging.Assert(() => v != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
                         int count = (int)v.Value;
-                        Debugging.Assert(() => count >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => count >= 0);
                         docCount++;
                         ordCount += count;
 
@@ -161,18 +161,18 @@ namespace Lucene.Net.Codecs.Asserting
                         {
                             ordIterator.MoveNext();
                             long? o = ordIterator.Current;
-                            Debugging.Assert(() => o != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => o != null);
                             long ord = o.Value;
-                            Debugging.Assert(() => ord >= 0 && ord < valueCount);
-                            Debugging.Assert(() => ord > lastOrd, () => "ord=" + ord + ",lastOrd=" + lastOrd);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord > lastOrd, () => "ord=" + ord + ",lastOrd=" + lastOrd);
                             seenOrds.Set(ord);
                             lastOrd = ord;
                         }
                     }
-                    Debugging.Assert(() => ordIterator.MoveNext() == false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ordIterator.MoveNext() == false);
 
-                    Debugging.Assert(() => docCount == maxDoc);
-                    Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == maxDoc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
                     CheckIterator(values.GetEnumerator(), valueCount, false);
                     CheckIterator(docToOrdCount.GetEnumerator(), maxDoc, false);
                     CheckIterator(ords.GetEnumerator(), ordCount, false);
@@ -203,10 +203,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (long? v in values)
                 {
-                    Debugging.Assert(() => v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
                     count++;
                 }
-                Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, false);
                 @in.AddNumericField(field, values);
             }
@@ -240,9 +240,9 @@ namespace Lucene.Net.Codecs.Asserting
                 for (long i = 0; i < expectedSize; i++)
                 {
                     bool hasNext = iterator.MoveNext();
-                    Debugging.Assert(() => hasNext);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext);
                     T v = iterator.Current;
-                    Debugging.Assert(() => allowNull || v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => allowNull || v != null);
 
                     // LUCENE.NET specific. removed call to Reset().
                     //try
@@ -255,7 +255,7 @@ namespace Lucene.Net.Codecs.Asserting
                     //    // ok
                     //}
                 }
-                Debugging.Assert(() => !iterator.MoveNext());
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !iterator.MoveNext());
                 /*try
                 {
                   //iterator.next();
@@ -285,42 +285,42 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override NumericDocValues GetNumeric(FieldInfo field)
             {
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
                 NumericDocValues values = @in.GetNumeric(field);
-                Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
                 return new AssertingNumericDocValues(values, maxDoc);
             }
 
             public override BinaryDocValues GetBinary(FieldInfo field)
             {
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
                 BinaryDocValues values = @in.GetBinary(field);
-                Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
                 return new AssertingBinaryDocValues(values, maxDoc);
             }
 
             public override SortedDocValues GetSorted(FieldInfo field)
             {
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
                 SortedDocValues values = @in.GetSorted(field);
-                Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
                 return new AssertingSortedDocValues(values, maxDoc);
             }
 
             public override SortedSetDocValues GetSortedSet(FieldInfo field)
             {
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
                 SortedSetDocValues values = @in.GetSortedSet(field);
-                Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
                 return new AssertingSortedSetDocValues(values, maxDoc);
             }
 
             public override IBits GetDocsWithField(FieldInfo field)
             {
-                Debugging.Assert(() => field.DocValuesType != DocValuesType.NONE);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType != DocValuesType.NONE);
                 IBits bits = @in.GetDocsWithField(field);
-                Debugging.Assert(() => bits != null);
-                Debugging.Assert(() => bits.Length == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => bits != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => bits.Length == maxDoc);
                 return new AssertingBits(bits);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
index 87efcba..ea40b54 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
@@ -32,15 +32,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer NormsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.NormsConsumer(state);
-            Debugging.Assert(() => consumer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
             return new AssertingNormsConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer NormsProducer(SegmentReadState state)
         {
-            Debugging.Assert(() => state.FieldInfos.HasNorms);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.FieldInfos.HasNorms);
             DocValuesProducer producer = @in.NormsProducer(state);
-            Debugging.Assert(() => producer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
     }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
index cc99fd3..69e981f 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override IEnumerator<string> GetEnumerator()
             {
                 IEnumerator<string> iterator = @in.GetEnumerator();
-                Debugging.Assert(() => iterator != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => iterator != null);
                 return iterator;
             }
 
@@ -105,7 +105,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override TermsConsumer AddField(FieldInfo field)
             {
                 TermsConsumer consumer = @in.AddField(field);
-                Debugging.Assert(() => consumer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
                 return new AssertingTermsConsumer(consumer, field);
             }
 
@@ -144,28 +144,28 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override PostingsConsumer StartTerm(BytesRef text)
             {
-                Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.START;
-                Debugging.Assert(() => lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
                 lastTerm = BytesRef.DeepCopyOf(text);
                 return lastPostingsConsumer = new AssertingPostingsConsumer(@in.StartTerm(text), fieldInfo, visitedDocs);
             }
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debugging.Assert(() => state == TermsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.START);
                 state = TermsConsumerState.INITIAL;
-                Debugging.Assert(() => text.Equals(lastTerm));
-                Debugging.Assert(() => stats.DocFreq > 0); // otherwise, this method should not be called.
-                Debugging.Assert(() => stats.DocFreq == lastPostingsConsumer.docFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => text.Equals(lastTerm));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0); // otherwise, this method should not be called.
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq == lastPostingsConsumer.docFreq);
                 sumDocFreq += stats.DocFreq;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debugging.Assert(() => stats.TotalTermFreq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.TotalTermFreq == -1);
                 }
                 else
                 {
-                    Debugging.Assert(() => stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
                     sumTotalTermFreq += stats.TotalTermFreq;
                 }
                 @in.FinishTerm(text, stats);
@@ -173,20 +173,20 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(long sumTotalTermFreq, long sumDocFreq, int docCount)
             {
-                Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.FINISHED;
-                Debugging.Assert(() => docCount >= 0);
-                Debugging.Assert(() => docCount == visitedDocs.Cardinality());
-                Debugging.Assert(() => sumDocFreq >= docCount);
-                Debugging.Assert(() => sumDocFreq == this.sumDocFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == visitedDocs.Cardinality());
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sumDocFreq >= docCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => sumDocFreq == this.sumDocFreq);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debugging.Assert(() => sumTotalTermFreq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq == -1);
                 }
                 else
                 {
-                    Debugging.Assert(() => sumTotalTermFreq >= sumDocFreq);
-                    Debugging.Assert(() => sumTotalTermFreq == this.sumTotalTermFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq >= sumDocFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq == this.sumTotalTermFreq);
                 }
                 @in.Finish(sumTotalTermFreq, sumDocFreq, docCount);
             }
@@ -222,17 +222,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDoc(int docID, int freq)
             {
-                Debugging.Assert(() => state == PostingsConsumerState.INITIAL);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.INITIAL);
                 state = PostingsConsumerState.START;
-                Debugging.Assert(() => docID >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debugging.Assert(() => freq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq == -1);
                     this.freq = 0; // we don't expect any positions here
                 }
                 else
                 {
-                    Debugging.Assert(() => freq > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                     this.freq = freq;
                     totalTermFreq += freq;
                 }
@@ -246,41 +246,41 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                Debugging.Assert(() => state == PostingsConsumerState.START);
-                Debugging.Assert(() => positionCount < freq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount < freq);
                 positionCount++;
-                Debugging.Assert(() => position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
                 lastPosition = position;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS)
                 {
-                    Debugging.Assert(() => startOffset >= 0);
-                    Debugging.Assert(() => startOffset >= lastStartOffset);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= lastStartOffset);
                     lastStartOffset = startOffset;
-                    Debugging.Assert(() => endOffset >= startOffset);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset >= startOffset);
                 }
                 else
                 {
-                    Debugging.Assert(() => startOffset == -1);
-                    Debugging.Assert(() => endOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
                 }
                 if (payload != null)
                 {
-                    Debugging.Assert(() => fieldInfo.HasPayloads);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo.HasPayloads);
                 }
                 @in.AddPosition(position, payload, startOffset, endOffset);
             }
 
             public override void FinishDoc()
             {
-                Debugging.Assert(() => state == PostingsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.START);
                 state = PostingsConsumerState.INITIAL;
                 if (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0)
                 {
-                    Debugging.Assert(() => positionCount == 0); // we should not have fed any positions!
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == 0); // we should not have fed any positions!
                 }
                 else
                 {
-                    Debugging.Assert(() => positionCount == freq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == freq);
                 }
                 @in.FinishDoc();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
index ca57617..d4d9d76 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void VisitDocument(int n, StoredFieldVisitor visitor)
             {
-                Debugging.Assert(() => n >= 0 && n < maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => n >= 0 && n < maxDoc);
                 @in.VisitDocument(n, visitor);
             }
 
@@ -100,9 +100,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numStoredFields)
             {
-                Debugging.Assert(() => docStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus != Status.STARTED);
                 @in.StartDocument(numStoredFields);
-                Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
                 fieldCount = numStoredFields;
                 numWritten++;
                 docStatus = Status.STARTED;
@@ -110,17 +110,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                Debugging.Assert(() => docStatus == Status.STARTED);
-                Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void WriteField(FieldInfo info, IIndexableField field)
             {
-                Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
                 @in.WriteField(info, field);
-                Debugging.Assert(() => fieldCount > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount > 0);
                 fieldCount--;
             }
 
@@ -131,10 +131,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
                 @in.Finish(fis, numDocs);
-                Debugging.Assert(() => fieldCount == 0);
-                Debugging.Assert(() => numDocs == numWritten);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numWritten);
             }
 
             protected override void Dispose(bool disposing)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
index 10a94d5..b7ce230 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
@@ -103,8 +103,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numVectorFields)
             {
-                Debugging.Assert(() => fieldCount == 0);
-                Debugging.Assert(() => docStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus != Status.STARTED);
                 @in.StartDocument(numVectorFields);
                 docStatus = Status.STARTED;
                 fieldCount = numVectorFields;
@@ -113,17 +113,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                Debugging.Assert(() => fieldCount == 0);
-                Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
             {
-                Debugging.Assert(() => termCount == 0);
-                Debugging.Assert(() => docStatus == Status.STARTED);
-                Debugging.Assert(() => fieldStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus != Status.STARTED);
                 @in.StartField(info, numTerms, positions, offsets, payloads);
                 fieldStatus = Status.STARTED;
                 termCount = numTerms;
@@ -132,8 +132,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishField()
             {
-                Debugging.Assert(() => termCount == 0);
-                Debugging.Assert(() => fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
                 @in.FinishField();
                 fieldStatus = Status.FINISHED;
                 --fieldCount;
@@ -141,9 +141,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartTerm(BytesRef term, int freq)
             {
-                Debugging.Assert(() => docStatus == Status.STARTED);
-                Debugging.Assert(() => fieldStatus == Status.STARTED);
-                Debugging.Assert(() => termStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus != Status.STARTED);
                 @in.StartTerm(term, freq);
                 termStatus = Status.STARTED;
                 positionCount = hasPositions ? freq : 0;
@@ -151,10 +151,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishTerm()
             {
-                Debugging.Assert(() => positionCount == 0);
-                Debugging.Assert(() => docStatus == Status.STARTED);
-                Debugging.Assert(() => fieldStatus == Status.STARTED);
-                Debugging.Assert(() => termStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus == Status.STARTED);
                 @in.FinishTerm();
                 termStatus = Status.FINISHED;
                 --termCount;
@@ -162,9 +162,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
             {
-                Debugging.Assert(() => docStatus == Status.STARTED);
-                Debugging.Assert(() => fieldStatus == Status.STARTED);
-                Debugging.Assert(() => termStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus == Status.STARTED);
                 @in.AddPosition(position, startOffset, endOffset, payload);
                 --positionCount;
             }
@@ -176,10 +176,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                Debugging.Assert(() => docCount == numDocs);
-                Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
-                Debugging.Assert(() => fieldStatus != Status.STARTED);
-                Debugging.Assert(() => termStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == numDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus != Status.STARTED);
                 @in.Finish(fis, numDocs);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
index dacda7f..ae218dd 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
         {
             public override void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes)
             {
-                Debugging.Assert(() => offset + length <= originalLength);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => offset + length <= originalLength);
                 if (bytes.Bytes.Length < originalLength)
                 {
                     bytes.Bytes = new byte[ArrayUtil.Oversize(originalLength, 1)];
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
index d46a3ad..8a461be 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (fi.IsIndexed)
                     {
                         bits |= IS_INDEXED;
-                        Debugging.Assert(() => fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
                         if (fi.IndexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= OMIT_TERM_FREQ_AND_POSITIONS;
@@ -103,7 +103,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         // only in RW case
                         output.WriteByte((byte)(sbyte)(fi.NormType == Index.DocValuesType.NONE ? 0 : 1));
                     }
-                    Debugging.Assert(() => fi.Attributes == null); // not used or supported
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.Attributes == null); // not used or supported
                 }
                 success = true;
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
index 5964172..a849aeb 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
@@ -81,7 +81,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override TermsConsumer AddField(FieldInfo field)
         {
-            Debugging.Assert(() => field.Number != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Number != -1);
             if (field.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0)
             {
                 throw new NotSupportedException("this codec cannot index offsets");
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                     lastDocID = docID;
 
-                    Debugging.Assert(() => docID < outerInstance.outerInstance.totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docID < outerInstance.outerInstance.totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
 
                     if (outerInstance.omitTF)
                     {
@@ -188,9 +188,9 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                 public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
                 {
-                    Debugging.Assert(() => outerInstance.outerInstance.proxOut != null);
-                    Debugging.Assert(() => startOffset == -1);
-                    Debugging.Assert(() => endOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.outerInstance.proxOut != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
                     //System.out.println("      w pos=" + position + " payl=" + payload);
                     int delta = position - lastPosition;
                     lastPosition = position;
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
index 6831153..9cd2cde 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddNumericField(FieldInfo field, IEnumerable<long?> values)
         {
-            Debugging.Assert(() => field.Number > lastFieldNumber, () => "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Number > lastFieldNumber, () => "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
             foreach (var n in values)
             {
                 if (((sbyte)(byte)(long)n) < sbyte.MinValue || ((sbyte)(byte)(long)n) > sbyte.MaxValue)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
index e7bd7d9..807b279 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public PreFlexRWStoredFieldsWriter(Directory directory, string segment, IOContext context)
         {
-            Debugging.Assert(() => directory != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => directory != null);
             this.directory = directory;
             this.segment = segment;
 
@@ -188,7 +188,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         fieldsStream.WriteInt64(J2N.BitConversion.DoubleToInt64Bits(field.GetDoubleValue().Value));
                         break;
                     default:
-                        Debugging.Assert(() => false);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                         break;
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
index 1f8fb40..1c42cd5 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
         {
-            Debugging.Assert(() => lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
             lastFieldName = info.Name;
             if (payloads)
             {
@@ -98,7 +98,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
             tvf.WriteByte((byte)bits);
 
-            Debugging.Assert(() => fieldCount <= numVectorFields);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount <= numVectorFields);
             if (fieldCount == numVectorFields)
             {
                 // last field of the document
@@ -148,7 +148,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            Debugging.Assert(() => payload == null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null);
             if (positions && offsets)
             {
                 // write position delta
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
index 3030f4c..61d3b9e 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
@@ -135,7 +135,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 output.WriteInt32(indexInterval); // write indexInterval
                 output.WriteInt32(skipInterval); // write skipInterval
                 output.WriteInt32(maxSkipLevels); // write maxSkipLevels
-                Debugging.Assert(InitUTF16Results);
+                if (Debugging.AssertsEnabled) Debugging.Assert(InitUTF16Results);
                 success = true;
             }
             finally
@@ -202,10 +202,10 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
 
             scratchBytes.CopyBytes(term);
-            Debugging.Assert(() => lastTerm.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastTerm.Offset == 0);
             UnicodeUtil.UTF8toUTF16(lastTerm.Bytes, 0, lastTerm.Length, utf16Result1);
 
-            Debugging.Assert(() => scratchBytes.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchBytes.Offset == 0);
             UnicodeUtil.UTF8toUTF16(scratchBytes.Bytes, 0, scratchBytes.Length, utf16Result2);
 
             int len;
@@ -243,10 +243,10 @@ namespace Lucene.Net.Codecs.Lucene3x
         /// </summary>
         public void Add(int fieldNumber, BytesRef term, TermInfo ti)
         {
-            Debugging.Assert(() => CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), () => "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), () => "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
 
-            Debugging.Assert(() => ti.FreqPointer >= lastTi.FreqPointer, () => "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
-            Debugging.Assert(() => ti.ProxPointer >= lastTi.ProxPointer, () => "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ti.FreqPointer >= lastTi.FreqPointer, () => "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ti.ProxPointer >= lastTi.ProxPointer, () => "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
 
             if (!isIndex && size % indexInterval == 0)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
index cd00949..62d6dc1 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
@@ -333,7 +333,7 @@ namespace Lucene.Net.Codecs.Lucene40
             index.WriteVInt64(maxAddress);
 
             int maxDoc = state.SegmentInfo.DocCount;
-            Debugging.Assert(() => maxDoc != int.MaxValue); // unsupported by the 4.0 impl
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => maxDoc != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -346,7 +346,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
             }
             // write sentinel
-            Debugging.Assert(() => currentPosition == maxAddress);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
         }
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             /* ordinals */
             int valueCount = dictionary.Count;
-            Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
@@ -439,7 +439,7 @@ namespace Lucene.Net.Codecs.Lucene40
         // the little vint encoding used for var-deref
         private static void WriteVInt16(IndexOutput o, int i)
         {
-            Debugging.Assert(() => i >= 0 && i <= short.MaxValue);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => i >= 0 && i <= short.MaxValue);
             if (i < 128)
             {
                 o.WriteByte((byte)(sbyte)i);
@@ -545,7 +545,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
-            Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
@@ -578,7 +578,7 @@ namespace Lucene.Net.Codecs.Lucene40
             long maxAddress = data.GetFilePointer() - startPos;
             index.WriteInt64(maxAddress);
 
-            Debugging.Assert(() => valueCount != int.MaxValue); // unsupported by the 4.0 impl
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, valueCount + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -588,14 +588,14 @@ namespace Lucene.Net.Codecs.Lucene40
                 currentPosition += v.Length;
             }
             // write sentinel
-            Debugging.Assert(() => currentPosition == maxAddress);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
 
             /* ordinals */
 
             int maxDoc = state.SegmentInfo.DocCount;
-            Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
             PackedInt32s.Writer ords = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
index a11809e..d4eb855 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene40FieldInfosFormat.IS_INDEXED;
-                        Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene40FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     // pack the DV types in one byte
                     byte dv = DocValuesByte(fi.DocValuesType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_DV_TYPE_KEY));
                     byte nrm = DocValuesByte(fi.NormType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_NORM_TYPE_KEY));
-                    Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
@@ -113,12 +113,12 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             if (type == DocValuesType.NONE)
             {
-                Debugging.Assert(() => legacyTypeAtt == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => legacyTypeAtt == null);
                 return 0;
             }
             else
             {
-                Debugging.Assert(() => legacyTypeAtt != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => legacyTypeAtt != null);
                 //return (sbyte)LegacyDocValuesType.ordinalLookup[legacyTypeAtt];
                 return (byte)legacyTypeAtt.ToLegacyDocValuesType();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
index 0cdfac0..d5b8e24 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
@@ -208,7 +208,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 skipListWriter.BufferSkip(df);
             }
 
-            Debugging.Assert(() => docID < totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + totalNumDocs);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID < totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + totalNumDocs);
 
             lastDocID = docID;
             if (indexOptions == IndexOptions.DOCS_ONLY)
@@ -234,12 +234,12 @@ namespace Lucene.Net.Codecs.Lucene40
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
             //if (DEBUG) System.out.println("SPW:     addPos pos=" + position + " payload=" + (payload == null ? "null" : (payload.Length + " bytes")) + " proxFP=" + proxOut.getFilePointer());
-            Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, () => "invalid indexOptions: " + indexOptions);
-            Debugging.Assert(() => proxOut != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, () => "invalid indexOptions: " + indexOptions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => proxOut != null);
 
             int delta = position - lastPosition;
 
-            Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
 
             lastPosition = position;
 
@@ -271,7 +271,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 // and the numbers aren't that much smaller anyways.
                 int offsetDelta = startOffset - lastOffset;
                 int offsetLength = endOffset - startOffset;
-                Debugging.Assert(() => offsetDelta >= 0 && offsetLength >= 0, () => "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => offsetDelta >= 0 && offsetLength >= 0, () => "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
                 if (offsetLength != lastOffsetLength)
                 {
                     proxOut.WriteVInt32(offsetDelta << 1 | 1);
@@ -308,11 +308,11 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             StandardTermState state_ = (StandardTermState)state;
             // if (DEBUG) System.out.println("SPW: finishTerm seg=" + segment + " freqStart=" + freqStart);
-            Debugging.Assert(() => state_.DocFreq > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.DocFreq > 0);
 
             // TODO: wasteful we are counting this (counting # docs
             // for this term) in two places?
-            Debugging.Assert(() => state_.DocFreq == df);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.DocFreq == df);
             state_.FreqStart = freqStart;
             state_.ProxStart = proxStart;
             if (df >= skipMinimum)
@@ -337,7 +337,7 @@ namespace Lucene.Net.Codecs.Lucene40
             @out.WriteVInt64(state_.FreqStart - lastState.FreqStart);
             if (state_.SkipOffset != -1)
             {
-                Debugging.Assert(() => state_.SkipOffset > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.SkipOffset > 0);
                 @out.WriteVInt64(state_.SkipOffset);
             }
             if (indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
index f8b50ee..d6ffba9 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
@@ -67,8 +67,8 @@ namespace Lucene.Net.Codecs.Lucene40
         /// </summary>
         public virtual void SetSkipData(int doc, bool storePayloads, int payloadLength, bool storeOffsets, int offsetLength)
         {
-            Debugging.Assert(() => storePayloads || payloadLength == -1);
-            Debugging.Assert(() => storeOffsets || offsetLength == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => storePayloads || payloadLength == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => storeOffsets || offsetLength == -1);
             this.curDoc = doc;
             this.curStorePayloads = storePayloads;
             this.curPayloadLength = payloadLength;
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
             if (curStorePayloads || curStoreOffsets)
             {
-                Debugging.Assert(() => curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
-                Debugging.Assert(() => curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
 
                 if (curPayloadLength == lastSkipPayloadLength[level] && curOffsetLength == lastSkipOffsetLength[level])
                 {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
index 9c87bf3..6c5c200 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
@@ -125,7 +125,7 @@ namespace Lucene.Net.Codecs.Lucene42
 
                     ++count;
                 }
-                Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
             }
 
             if (uniqueValues != null)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
index 9889f63..11287be 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene42FieldInfosFormat.IS_INDEXED;
-                        Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene42FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     // pack the DV types in one byte
                     var dv = DocValuesByte(fi.DocValuesType);
                     var nrm = DocValuesByte(fi.NormType);
-                    Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
index d8e4ed8..8734489 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Codecs.MockIntBlock
                     {
                         buffer[0] = input.ReadVInt32();
                         int count = buffer[0] <= 3 ? baseBlockSize - 1 : 2 * baseBlockSize - 1;
-                        Debugging.Assert(() => buffer.Length >= count, () => "buffer.length=" + buffer.Length + " count=" + count);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Length >= count, () => "buffer.length=" + buffer.Length + " count=" + count);
                         for (int i = 0; i < count; i++)
                         {
                             buffer[i + 1] = input.ReadVInt32();
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
index 75925c1..8481e0d 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.MockRandom
             private static string GetExtension(string fileName)
             {
                 int idx = fileName.IndexOf('.');
-                Debugging.Assert(() => idx != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => idx != -1);
                 return fileName.Substring(idx);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
index d4565c2..ba4029e 100644
--- a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
@@ -290,8 +290,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debugging.Assert(() => stats.DocFreq > 0);
-                Debugging.Assert(() => stats.DocFreq == current.docs.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq == current.docs.Count);
                 current.totalTermFreq = stats.TotalTermFreq;
                 field.termToDocs[current.term] = current;
             }
@@ -324,8 +324,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                Debugging.Assert(() => startOffset == -1);
-                Debugging.Assert(() => endOffset == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
                 current.positions[posUpto] = position;
                 if (payload != null && payload.Length > 0)
                 {
@@ -341,7 +341,7 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishDoc()
             {
-                Debugging.Assert(() => posUpto == current.positions.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => posUpto == current.positions.Length);
             }
         }
 
diff --git a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
index 2c56376..c545d60 100644
--- a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             liveDocs = new Bits.MatchNoBits(@in.MaxDoc);
-            Debugging.Assert(() => MaxDoc == 0 || HasDeletions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == 0 || HasDeletions);
         }
 
         public override IBits LiveDocs => liveDocs;
diff --git a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
index 4657a16..077b270 100644
--- a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public override IEnumerator<string> GetEnumerator()
         {
             IEnumerator<string> iterator = base.GetEnumerator();
-            Debugging.Assert(() => iterator != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => iterator != null);
             return iterator;
         }
 
@@ -59,8 +59,8 @@ namespace Lucene.Net.Index
         public override TermsEnum Intersect(CompiledAutomaton automaton, BytesRef bytes)
         {
             TermsEnum termsEnum = m_input.Intersect(automaton, bytes);
-            Debugging.Assert(() => termsEnum != null);
-            Debugging.Assert(() => bytes == null || bytes.IsValid());
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => bytes == null || bytes.IsValid());
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
 
@@ -73,7 +73,7 @@ namespace Lucene.Net.Index
                 reuse = ((AssertingAtomicReader.AssertingTermsEnum)reuse).m_input;
             }
             TermsEnum termsEnum = base.GetIterator(reuse);
-            Debugging.Assert(() => termsEnum != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
     }
@@ -102,7 +102,7 @@ namespace Lucene.Net.Index
             try
             {
                 int docid = @in.DocID;
-                Debugging.Assert(() => docid == -1, () => @in.GetType() + ": invalid initial doc id: " + docid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docid == -1, () => @in.GetType() + ": invalid initial doc id: " + docid);
             }
             catch (NotSupportedException /*e*/)
             {
@@ -116,9 +116,9 @@ namespace Lucene.Net.Index
 
         public override int NextDoc()
         {
-            Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
             int nextDoc = base.NextDoc();
-            Debugging.Assert(() => nextDoc > doc, () => "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextDoc > doc, () => "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
             if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -127,16 +127,16 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            Debugging.Assert(() => base.DocID == nextDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == nextDoc);
             return doc = nextDoc;
         }
 
         public override int Advance(int target)
         {
-            Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
-            Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
             int advanced = base.Advance(target);
-            Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
             if (advanced == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -145,7 +145,7 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            Debugging.Assert(() => base.DocID == advanced);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == advanced);
             return doc = advanced;
         }
 
@@ -153,7 +153,7 @@ namespace Lucene.Net.Index
         {
             get
             {
-                Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                 return doc;
             }
         }
@@ -162,10 +162,10 @@ namespace Lucene.Net.Index
         {
             get
             {
-                Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
-                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                 int freq = base.Freq;
-                Debugging.Assert(() => freq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                 return freq;
             }
         }
@@ -186,7 +186,7 @@ namespace Lucene.Net.Index
 
         public override long Get(int docID)
         {
-            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
             return @in.Get(docID);
         }
     }
@@ -206,10 +206,10 @@ namespace Lucene.Net.Index
 
         public override void Get(int docID, BytesRef result)
         {
-            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
             @in.Get(docID, result);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
         }
     }
 
@@ -226,23 +226,23 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            Debugging.Assert(() => valueCount >= 0 && valueCount <= maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount >= 0 && valueCount <= maxDoc);
         }
 
         public override int GetOrd(int docID)
         {
-            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
             int ord = @in.GetOrd(docID);
-            Debugging.Assert(() => ord >= -1 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= -1 && ord < valueCount);
             return ord;
         }
 
         public override void LookupOrd(int ord, BytesRef result)
         {
-            Debugging.Assert(() => ord >= 0 && ord < valueCount);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
             @in.LookupOrd(ord, result);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
         }
 
         public override int ValueCount
@@ -250,25 +250,25 @@ namespace Lucene.Net.Index
             get
             {
                 int valueCount = @in.ValueCount;
-                Debugging.Assert(() => valueCount == this.valueCount); // should not change
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override void Get(int docID, BytesRef result)
         {
-            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
             @in.Get(docID, result);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
         }
 
         public override int LookupTerm(BytesRef key)
         {
-            Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
             int result = @in.LookupTerm(key);
-            Debugging.Assert(() => result < valueCount);
-            Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => result < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
             return result;
         }
     }
@@ -287,32 +287,32 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            Debugging.Assert(() => valueCount >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount >= 0);
         }
 
         public override long NextOrd()
         {
-            Debugging.Assert(() => lastOrd != NO_MORE_ORDS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastOrd != NO_MORE_ORDS);
             long ord = @in.NextOrd();
-            Debugging.Assert(() => ord < valueCount);
-            Debugging.Assert(() => ord == NO_MORE_ORDS || ord > lastOrd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord == NO_MORE_ORDS || ord > lastOrd);
             lastOrd = ord;
             return ord;
         }
 
         public override void SetDocument(int docID)
         {
-            Debugging.Assert(() => docID >= 0 && docID < maxDoc, () => "docid=" + docID + ",maxDoc=" + maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc, () => "docid=" + docID + ",maxDoc=" + maxDoc);
             @in.SetDocument(docID);
             lastOrd = -2;
         }
 
         public override void LookupOrd(long ord, BytesRef result)
         {
-            Debugging.Assert(() => ord >= 0 && ord < valueCount);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
             @in.LookupOrd(ord, result);
-            Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
         }
 
         public override long ValueCount
@@ -320,17 +320,17 @@ namespace Lucene.Net.Index
             get
             {
                 long valueCount = @in.ValueCount;
-                Debugging.Assert(() => valueCount == this.valueCount); // should not change
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override long LookupTerm(BytesRef key)
         {
-            Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
             long result = @in.LookupTerm(key);
-            Debugging.Assert(() => result < valueCount);
-            Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => result < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
             return result;
         }
     }
@@ -348,7 +348,7 @@ namespace Lucene.Net.Index
 
         public virtual bool Get(int index)
         {
-            Debugging.Assert(() => index >= 0 && index < Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => index >= 0 && index < Length);
             return @in.Get(index);
         }
 
@@ -365,10 +365,10 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             // check some basic reader sanity
-            Debugging.Assert(() => @in.MaxDoc >= 0);
-            Debugging.Assert(() => @in.NumDocs <= @in.MaxDoc);
-            Debugging.Assert(() => @in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
-            Debugging.Assert(() => !@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.MaxDoc >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.NumDocs <= @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
         }
 
         public override Fields Fields
@@ -409,7 +409,7 @@ namespace Lucene.Net.Index
 
             public override DocsEnum Docs(IBits liveDocs, DocsEnum reuse, DocsFlags flags)
             {
-                Debugging.Assert(() => state == State.POSITIONED, () => "Docs(...) called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Docs(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -423,7 +423,7 @@ namespace Lucene.Net.Index
 
             public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
             {
-                Debugging.Assert(() => state == State.POSITIONED, () => "DocsAndPositions(...) called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "DocsAndPositions(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -439,7 +439,7 @@ namespace Lucene.Net.Index
             // someone should not call next() after it returns null!!!!
             public override BytesRef Next()
             {
-                Debugging.Assert(() => state == State.INITIAL || state == State.POSITIONED, () => "Next() called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.INITIAL || state == State.POSITIONED, () => "Next() called on unpositioned TermsEnum");
                 BytesRef result = base.Next();
                 if (result == null)
                 {
@@ -447,7 +447,7 @@ namespace Lucene.Net.Index
                 }
                 else
                 {
-                    Debugging.Assert(result.IsValid);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
                     state = State.POSITIONED;
                 }
                 return result;
@@ -457,7 +457,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state == State.POSITIONED, () => "Ord called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Ord called on unpositioned TermsEnum");
                     return base.Ord;
                 }
             }
@@ -466,7 +466,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state == State.POSITIONED, () => "DocFreq called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "DocFreq called on unpositioned TermsEnum");
                     return base.DocFreq;
                 }
             }
@@ -475,7 +475,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state == State.POSITIONED, () => "TotalTermFreq called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "TotalTermFreq called on unpositioned TermsEnum");
                     return base.TotalTermFreq;
                 }
             }
@@ -484,9 +484,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state == State.POSITIONED, () => "Term called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Term called on unpositioned TermsEnum");
                     BytesRef ret = base.Term;
-                    Debugging.Assert(() => ret == null || ret.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ret == null || ret.IsValid());
                     return ret;
                 }
             }
@@ -499,7 +499,7 @@ namespace Lucene.Net.Index
 
             public override SeekStatus SeekCeil(BytesRef term)
             {
-                Debugging.Assert(term.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid);
                 SeekStatus result = base.SeekCeil(term);
                 if (result == SeekStatus.END)
                 {
@@ -514,7 +514,7 @@ namespace Lucene.Net.Index
 
             public override bool SeekExact(BytesRef text)
             {
-                Debugging.Assert(text.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(text.IsValid);
                 if (base.SeekExact(text))
                 {
                     state = State.POSITIONED;
@@ -529,13 +529,13 @@ namespace Lucene.Net.Index
 
             public override TermState GetTermState()
             {
-                Debugging.Assert(() => state == State.POSITIONED, () => "GetTermState() called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "GetTermState() called on unpositioned TermsEnum");
                 return base.GetTermState();
             }
 
             public override void SeekExact(BytesRef term, TermState state)
             {
-                Debugging.Assert(term.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid);
                 base.SeekExact(term, state);
                 this.state = State.POSITIONED;
             }
@@ -556,15 +556,15 @@ namespace Lucene.Net.Index
                 : base(@in)
             {
                 int docid = @in.DocID;
-                Debugging.Assert(() => docid == -1, () => "invalid initial doc id: " + docid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docid == -1, () => "invalid initial doc id: " + docid);
                 doc = -1;
             }
 
             public override int NextDoc()
             {
-                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
                 int nextDoc = base.NextDoc();
-                Debugging.Assert(() => nextDoc > doc, () => "backwards nextDoc from " + doc + " to " + nextDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => nextDoc > doc, () => "backwards nextDoc from " + doc + " to " + nextDoc);
                 positionCount = 0;
                 if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -576,16 +576,16 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                Debugging.Assert(() => base.DocID == nextDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == nextDoc);
                 return doc = nextDoc;
             }
 
             public override int Advance(int target)
             {
-                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
-                Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
                 int advanced = base.Advance(target);
-                Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
                 positionCount = 0;
                 if (advanced == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -597,7 +597,7 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                Debugging.Assert(() => base.DocID == advanced);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == advanced);
                 return doc = advanced;
             }
 
@@ -605,7 +605,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                     return doc;
                 }
             }
@@ -614,21 +614,21 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
-                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                     int freq = base.Freq;
-                    Debugging.Assert(() => freq > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
                     return freq;
                 }
             }
 
             public override int NextPosition()
             {
-                Debugging.Assert(() => state != DocsEnumState.START, () => "NextPosition() called before NextDoc()/Advance()");
-                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextPosition() called after NO_MORE_DOCS");
-                Debugging.Assert(() => positionCount < positionMax, () => "NextPosition() called more than Freq times!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "NextPosition() called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextPosition() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount < positionMax, () => "NextPosition() called more than Freq times!");
                 int position = base.NextPosition();
-                Debugging.Assert(() => position >= 0 || position == -1, () => "invalid position: " + position);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => position >= 0 || position == -1, () => "invalid position: " + position);
                 positionCount++;
                 return position;
             }
@@ -637,9 +637,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state != DocsEnumState.START, () => "StartOffset called before NextDoc()/Advance()");
-                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "StartOffset called after NO_MORE_DOCS");
-                    Debugging.Assert(() => positionCount > 0, () => "StartOffset called before NextPosition()!");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "StartOffset called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "StartOffset called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "StartOffset called before NextPosition()!");
                     return base.StartOffset;
                 }
             }
@@ -648,20 +648,20 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debugging.Assert(() => state != DocsEnumState.START, () => "EndOffset called before NextDoc()/Advance()");
-                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "EndOffset called after NO_MORE_DOCS");
-                    Debugging.Assert(() => positionCount > 0, () => "EndOffset called before NextPosition()!");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "EndOffset called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "EndOffset called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "EndOffset called before NextPosition()!");
                     return base.EndOffset;
                 }
             }
 
             public override BytesRef GetPayload()
             {
-                Debugging.Assert(() => state != DocsEnumState.START, () => "GetPayload() called before NextDoc()/Advance()");
-                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "GetPayload() called after NO_MORE_DOCS");
-                Debugging.Assert(() => positionCount > 0, () => "GetPayload() called before NextPosition()!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "GetPayload() called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "GetPayload() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "GetPayload() called before NextPosition()!");
                 BytesRef payload = base.GetPayload();
-                Debugging.Assert(() => payload == null || payload.IsValid() && payload.Length > 0, () => "GetPayload() returned payload with invalid length!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null || payload.IsValid() && payload.Length > 0, () => "GetPayload() returned payload with invalid length!");
                 return payload;
             }
         }
@@ -681,13 +681,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.DocValuesType == DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.NUMERIC);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
                 return null;
             }
         }
@@ -698,13 +698,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.DocValuesType == DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.BINARY);
                 return new AssertingBinaryDocValues(dv, MaxDoc);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.BINARY);
                 return null;
             }
         }
@@ -715,13 +715,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED);
                 return new AssertingSortedDocValues(dv, MaxDoc);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED);
                 return null;
             }
         }
@@ -732,13 +732,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED_SET);
                 return new AssertingSortedSetDocValues(dv, MaxDoc);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
                 return null;
             }
         }
@@ -749,13 +749,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.HasNorms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.HasNorms);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.HasNorms == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.HasNorms == false);
                 return null;
             }
         }
@@ -769,13 +769,13 @@ namespace Lucene.Net.Index
                 IBits liveDocs = base.LiveDocs;
                 if (liveDocs != null)
                 {
-                    Debugging.Assert(() => MaxDoc == liveDocs.Length);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == liveDocs.Length);
                     liveDocs = new AssertingBits(liveDocs);
                 }
                 else
                 {
-                    Debugging.Assert(() => MaxDoc == NumDocs);
-                    Debugging.Assert(() => !HasDeletions);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == NumDocs);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !HasDeletions);
                 }
                 return liveDocs;
             }
@@ -787,14 +787,14 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (docsWithField != null)
             {
-                Debugging.Assert(() => fi != null);
-                Debugging.Assert(() => fi.HasDocValues);
-                Debugging.Assert(() => MaxDoc == docsWithField.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.HasDocValues);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == docsWithField.Length);
                 docsWithField = new AssertingBits(docsWithField);
             }
             else
             {
-                Debugging.Assert(() => fi == null || fi.HasDocValues == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.HasDocValues == false);
             }
             return docsWithField;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
index 0ba88c9..e0ab0ac 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader))).GetNumericDocValues("dv");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                     }
@@ -159,7 +159,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv");
                         Assert.AreEqual((long)J2N.BitConversion.SingleToInt32Bits(5.7f), dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - cast required because types don't match (xUnit checks this)
                     }
@@ -201,7 +201,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv2");
@@ -248,7 +248,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv1");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef(longTerm), scratch);
@@ -297,7 +297,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         BinaryDocValues dv2 = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv2");
@@ -346,7 +346,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv1");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -399,7 +399,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv2");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -438,7 +438,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(1L, dv.Get(0)); // LUCENENET specific - 1L required because types don't match (xUnit checks this)
                     Assert.AreEqual(2L, dv.Get(1)); // LUCENENET specific - 2L required because types don't match (xUnit checks this)
@@ -473,7 +473,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     for (int i = 0; i < 2; i++)
                     {
@@ -517,7 +517,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(long.MinValue, dv.Get(0));
                     Assert.AreEqual(long.MaxValue, dv.Get(1));
@@ -549,7 +549,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(-8841491950446638677L, dv.Get(0));
                     Assert.AreEqual(9062230939892376225L, dv.Get(1));
@@ -591,7 +591,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -627,7 +627,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     for (int i = 0; i < 2; i++)
@@ -684,7 +684,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                         dv.LookupOrd(dv.GetOrd(hits.ScoreDocs[i].Doc), scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -717,7 +717,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -755,7 +755,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount);
                     BytesRef scratch = new BytesRef();
@@ -797,7 +797,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount); // 2 ords
                     BytesRef scratch = new BytesRef();
@@ -894,7 +894,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -925,7 +925,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -1045,7 +1045,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     Assert.AreEqual(0, dv.GetOrd(0));
@@ -1080,7 +1080,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1114,7 +1114,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1146,7 +1146,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1174,7 +1174,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1205,7 +1205,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1239,7 +1239,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1277,7 +1277,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1494,7 +1494,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    Debugging.Assert(() => numDocs > 256);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -1580,7 +1580,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    Debugging.Assert(() => numDocs > 256);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -2649,13 +2649,13 @@ namespace Lucene.Net.Index
                             }
                             for (int j = 0; j < stringValues.Length; j++)
                             {
-                                Debugging.Assert(() => docValues != null);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => docValues != null);
                                 long ord = docValues.NextOrd();
-                                Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
                                 docValues.LookupOrd(ord, scratch);
                                 Assert.AreEqual(stringValues[j], scratch.Utf8ToString());
                             }
-                            Debugging.Assert(() => docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
                         }
                     }
                 } // ir.Dispose();
diff --git a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
index de00107..7498cfe 100644
--- a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
@@ -239,7 +239,7 @@ namespace Lucene.Net.Index
                     posUpto = freq;
                     return 0;
                 }
-                Debugging.Assert(() => posUpto < freq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => posUpto < freq);
 
                 if (posUpto == 0 && random.NextBoolean())
                 {
diff --git a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
index dca1e12..528d0c9 100644
--- a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
+++ b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
@@ -106,7 +106,7 @@ namespace Lucene.Net.Index
                 {
                     foreach (SegmentCommitInfo info in merge.Segments)
                     {
-                        Debugging.Assert(() => segmentsToMerge.ContainsKey(info));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => segmentsToMerge.ContainsKey(info));
                     }
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
index 2017704..2b0436f 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Index
                 }
                 previousMappings[name] = codec;
                 // Safety:
-                Debugging.Assert(() => previousMappings.Count < 10000, () => "test went insane");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => previousMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
@@ -115,7 +115,7 @@ namespace Lucene.Net.Index
                 }
                 previousDVMappings[name] = codec;
                 // Safety:
-                Debugging.Assert(() => previousDVMappings.Count < 10000, () => "test went insane");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => previousDVMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
diff --git a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
index 97c8f63..52faf55 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public RandomDocumentsWriterPerThreadPool(int maxNumPerThreads, Random random)
             : base(maxNumPerThreads)
         {
-            Debugging.Assert(() => MaxThreadStates >= 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxThreadStates >= 1);
             states = new ThreadState[maxNumPerThreads];
             this.random = new Random(random.Next());
             this.maxRetry = 1 + random.Next(10);
@@ -56,14 +56,14 @@ namespace Lucene.Net.Index
                     }
                 }
             }
-            Debugging.Assert(() => NumThreadStatesActive > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => NumThreadStatesActive > 0);
             for (int i = 0; i < maxRetry; i++)
             {
                 int ord = random.Next(NumThreadStatesActive);
                 lock (this)
                 {
                     threadState = states[ord];
-                    Debugging.Assert(() => threadState != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => threadState != null);
                 }
 
                 if (threadState.TryLock())
@@ -89,12 +89,12 @@ namespace Lucene.Net.Index
                 if (newThreadState != null) // did we get a new state?
                 {
                     threadState = states[NumThreadStatesActive - 1] = newThreadState;
-                    //Debugging.Assert(threadState.HeldByCurrentThread);
+                    //if (Debugging.AssertsEnabled) Debugging.Assert(threadState.HeldByCurrentThread);
                     return threadState;
                 }
                 // if no new state is available lock the random one
             }
-            Debugging.Assert(() => threadState != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => threadState != null);
             threadState.@Lock();
             return threadState;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
index 146e070..91a368e 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
@@ -440,7 +440,7 @@ namespace Lucene.Net.Index
                         Console.WriteLine("RIW: doRandomForceMerge(" + limit + ")");
                     }
                     IndexWriter.ForceMerge(limit);
-                    Debugging.Assert(() => !doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, () => "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, () => "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
                 }
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
index e2dbc3b..176882c 100644
--- a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
@@ -227,7 +227,7 @@ namespace Lucene.Net.Index
                                 if (toDeleteSubDocs.Count > 0 && Random.NextBoolean())
                                 {
                                     delSubDocs = toDeleteSubDocs[Random.Next(toDeleteSubDocs.Count)];
-                                    Debugging.Assert(() => !delSubDocs.Deleted);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !delSubDocs.Deleted);
                                     toDeleteSubDocs.Remove(delSubDocs);
                                     // Update doc block, replacing prior packID
                                     packID = delSubDocs.PackID;
@@ -364,7 +364,7 @@ namespace Lucene.Net.Index
 
                             foreach (SubDocs subDocs in toDeleteSubDocs)
                             {
-                                Debugging.Assert(() => !subDocs.Deleted);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => !subDocs.Deleted);
                                 delPackIDs.Add(subDocs.PackID);
                                 outerInstance.DeleteDocuments(new Term("packID", subDocs.PackID));
                                 subDocs.Deleted = true;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
index 4d88aa5..c3de506 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Search
                 try
                 {
                     bool remaining = @in.Score(collector, DocsEnum.NO_MORE_DOCS);
-                    Debugging.Assert(() => !remaining);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !remaining);
                 }
 #pragma warning disable 168
                 catch (NotSupportedException e)
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
index b2e7795..f183d86 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
         {
             if (inOrder || !AcceptsDocsOutOfOrder)
             {
-                Debugging.Assert(() => doc > lastCollected, () => "Out of order : " + lastCollected + " " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc > lastCollected, () => "Out of order : " + lastCollected + " " + doc);
             }
             @in.Collect(doc);
             lastCollected = doc;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
index 72351d5..ed7ae45 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
@@ -105,10 +105,10 @@ namespace Lucene.Net.Search
 
         public override float GetScore()
         {
-            Debugging.Assert(Iterating);
+            if (Debugging.AssertsEnabled) Debugging.Assert(Iterating);
             float score = @in.GetScore();
-            Debugging.Assert(() => !float.IsNaN(score));
-            Debugging.Assert(() => !float.IsNaN(score));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !float.IsNaN(score));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !float.IsNaN(score));
             return score;
         }
 
@@ -125,7 +125,7 @@ namespace Lucene.Net.Search
         {
             get
             {
-                Debugging.Assert(Iterating);
+                if (Debugging.AssertsEnabled) Debugging.Assert(Iterating);
                 return @in.Freq;
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
index 14db582..8f046f8 100644
--- a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
+++ b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search
 
         private static IndexReader MakeEmptyIndex(Random random, int numDocs)
         {
-            Debugging.Assert(() => numDocs > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
             Directory d = new MockDirectoryWrapper(random, new RAMDirectory());
             IndexWriter w = new IndexWriter(d, new IndexWriterConfig(LuceneTestCase.TEST_VERSION_CURRENT, new MockAnalyzer(random)));
             for (int i = 0; i < numDocs; i++)
@@ -487,7 +487,7 @@ namespace Lucene.Net.Search
                     leafPtr++;
                 }
                 lastReader[0] = (AtomicReader)context.Reader;
-                Debugging.Assert(() => readerContextArray[leafPtr].Reader == context.Reader);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => readerContextArray[leafPtr].Reader == context.Reader);
                 this.scorer = null;
                 lastDoc[0] = -1;
             }
diff --git a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
index f0cf871..811bcb7 100644
--- a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
+++ b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
@@ -71,7 +71,7 @@ namespace Lucene.Net.Search
         {
             lock (this)
             {
-                Debugging.Assert(() => field != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
                 if (!previousMappings.TryGetValue(field, out Similarity sim) || sim == null)
                 {
                     sim = knownSims[Math.Max(0, Math.Abs(perFieldSeed ^ field.GetHashCode())) % knownSims.Count];
diff --git a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
index 9b770f4..78f47d9 100644
--- a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
@@ -220,7 +220,7 @@ namespace Lucene.Net.Search
                 }
                 else
                 {
-                    Debugging.Assert(() => searchAfter == null); // not supported yet
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => searchAfter == null); // not supported yet
                     return s.LocalSearch(q, numHits, sort);
                 }
             }
@@ -306,7 +306,7 @@ namespace Lucene.Net.Search
                     this.outerInstance = nodeState;
                     this.nodeVersions = nodeVersions;
                     MyNodeID = nodeID;
-                    Debugging.Assert(() => MyNodeID == nodeState.MyNodeID, () => "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MyNodeID == nodeState.MyNodeID, () => "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
                 }
 
                 public override Query Rewrite(Query original)
@@ -348,7 +348,7 @@ namespace Lucene.Net.Search
 
                 public override TermStatistics TermStatistics(Term term, TermContext context)
                 {
-                    Debugging.Assert(() => term != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
                     long docFreq = 0;
                     long totalTermFreq = 0;
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
@@ -364,7 +364,7 @@ namespace Lucene.Net.Search
                             subStats = outerInstance.termStatsCache[key];
                             // We pre-cached during rewrite so all terms
                             // better be here...
-                            Debugging.Assert(() => subStats != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => subStats != null);
                         }
 
                         long nodeDocFreq = subStats.DocFreq;
@@ -419,7 +419,7 @@ namespace Lucene.Net.Search
                         }
                         // Collection stats are pre-shared on reopen, so,
                         // we better not have a cache miss:
-                        Debugging.Assert(() => nodeStats != null, () => "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeStats != null, () => "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
 
                         long nodeDocCount = nodeStats.DocCount;
                         if (docCount >= 0 && nodeDocCount >= 0)
@@ -451,7 +451,7 @@ namespace Lucene.Net.Search
                             sumDocFreq = -1;
                         }
 
-                        Debugging.Assert(() => nodeStats.MaxDoc >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeStats.MaxDoc >= 0);
                         maxDoc += nodeStats.MaxDoc;
                     }
 
@@ -551,7 +551,7 @@ namespace Lucene.Net.Search
 
                 public override TopFieldDocs Search(Query query, int numHits, Sort sort)
                 {
-                    Debugging.Assert(() => sort != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sort != null);
                     TopDocs[] shardHits = new TopDocs[nodeVersions.Length];
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
                     {
@@ -604,7 +604,7 @@ namespace Lucene.Net.Search
 
             public void InitSearcher(long[] nodeVersions)
             {
-                Debugging.Assert(() => currentShardSearcher == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentShardSearcher == null);
                 Array.Copy(nodeVersions, 0, currentNodeVersions, 0, currentNodeVersions.Length);
                 currentShardSearcher = new ShardIndexSearcher(this, GetCurrentNodeVersions(), Mgr.Acquire().IndexReader, MyNodeID);
             }
@@ -781,8 +781,8 @@ namespace Lucene.Net.Search
             for (int nodeID = 0; nodeID < numNodes; nodeID++)
             {
                 IndexSearcher s = m_nodes[nodeID].Mgr.Acquire();
-                Debugging.Assert(() => nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
-                Debugging.Assert(() => s != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => s != null);
                 try
                 {
                     BroadcastNodeReopen(nodeID, nodeVersions[nodeID], s);
diff --git a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
index 16e968f..60aa77d 100644
--- a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
@@ -963,7 +963,7 @@ namespace Lucene.Net.Store
                                             {
                                                 if (endSet.Contains(s) && !startSet.Contains(s))
                                                 {
-                                                    Debugging.Assert(() => pendingDeletions.Contains(s));
+                                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingDeletions.Contains(s));
                                                     if (LuceneTestCase.Verbose)
                                                     {
                                                         Console.WriteLine("MDW: Unreferenced check: Ignoring referenced file: " + s + " " + 
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Store
                                         extras += "\n\nThese files we had previously tried to delete, but couldn't: " + pendingDeletions;
                                     }
 
-                                    Debugging.Assert(() => false, () => "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
                                 }
 
                                 DirectoryReader ir1 = DirectoryReader.Open(this);
@@ -1034,7 +1034,7 @@ namespace Lucene.Net.Store
                                 DirectoryReader ir2 = DirectoryReader.Open(this);
                                 int numDocs2 = ir2.NumDocs;
                                 ir2.Dispose();
-                                Debugging.Assert(() => numDocs1 == numDocs2, () => "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs1 == numDocs2, () => "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
                             }
                         }
                     }
diff --git a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
index 861bb3e..3d9ea80 100644
--- a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
@@ -259,7 +259,7 @@ namespace Lucene.Net.Util
         [ExceptionToNetNumericConvention] // LUCENENET: This is for making test porting easier, keeping as-is
         internal int randomIntBetween(int min, int max)
         {
-            Debugging.Assert(() => max >= min, () => "max must be >= min: " + min + ", " + max);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => max >= min, () => "max must be >= min: " + min + ", " + max);
             long range = (long)max - (long)min;
             if (range < int.MaxValue)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
index 2f2b307..52e6904 100644
--- a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
@@ -191,7 +191,7 @@ namespace Lucene.Net.Util.Automaton
                 }
             }
 
-            Debugging.Assert(() => code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), () => "code=" + code + " min=" + t.Min + " max=" + t.Max);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), () => "code=" + code + " min=" + t.Min + " max=" + t.Max);
             return code;
         }
 
@@ -399,7 +399,7 @@ namespace Lucene.Net.Util.Automaton
         {
             int numStates = a.GetNumberOfStates();
             a.ClearNumberedStates(); // force recomputation of cached numbered states
-            Debugging.Assert(() => numStates == a.GetNumberOfStates(), () => "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numStates == a.GetNumberOfStates(), () => "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
         }
     }
 
diff --git a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
index 83f4ded..1c74e96 100644
--- a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
@@ -56,7 +56,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static BitSet RandomSet(int numBits, int numBitsSet)
         {
-            Debugging.Assert(() => numBitsSet <= numBits);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numBitsSet <= numBits);
             BitSet set = new BitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
index db6aea8..e573e12 100644
--- a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util
 
         public override void Message(string component, string message)
         {
-            Debugging.Assert(() => !message.Contains("non-bulk merges"));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !message.Contains("non-bulk merges"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
index a7929e0..875dc69 100644
--- a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
+++ b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
@@ -103,7 +103,7 @@ namespace Lucene.Net.Util.Fst
             for (int i = 0; i < ir.Length; i++)
             {
                 int x = ir.Int32s[ir.Offset + i];
-                Debugging.Assert(() => x >= 0 && x <= 255);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => x >= 0 && x <= 255);
                 br.Bytes[i] = (byte)x;
             }
             br.Length = ir.Length;
@@ -219,7 +219,7 @@ namespace Lucene.Net.Util.Fst
         // of the term prefix that matches
         private T Run(FST<T> fst, Int32sRef term, int[] prefixLength)
         {
-            Debugging.Assert(() => prefixLength == null || prefixLength.Length == 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLength == null || prefixLength.Length == 1);
             FST.Arc<T> arc = fst.GetFirstArc(new FST.Arc<T>());
             T NO_OUTPUT = fst.Outputs.NoOutput;
             T output = NO_OUTPUT;
@@ -690,7 +690,7 @@ namespace Lucene.Net.Util.Fst
                             if (!termsMap.ContainsKey(term) && term.CompareTo(pairs[upto].Input) > 0)
                             {
                                 int pos = pairs.BinarySearch(new InputOutput<T>(term, default(T)));
-                                Debugging.Assert(() => pos < 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < 0);
                                 upto = -(pos + 1);
 
                                 if (random.NextBoolean())
@@ -887,7 +887,7 @@ namespace Lucene.Net.Util.Fst
                     }
                     else
                     {
-                        Debugging.Assert(() => prune2 > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => prune2 > 0);
                         if (prune2 > 1 && cmo.Count >= prune2)
                         {
                             keep = true;
diff --git a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
index d89f9b4..bf79a35 100644
--- a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
@@ -2678,7 +2678,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermsStatisticsEquals(string info, Terms leftTerms, Terms rightTerms)
         {
-            Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount, info);
@@ -3053,7 +3053,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertStoredFieldsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Document leftDoc = leftReader.Document(i);
@@ -3100,7 +3100,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermVectorsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Fields leftFields = leftReader.GetTermVectors(i);
@@ -3270,7 +3270,7 @@ namespace Lucene.Net.Util
         // TODO: this is kinda stupid, we don't delete documents in the test.
         public virtual void AssertDeletedDocsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debugging.Assert(() => leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
             IBits leftBits = MultiFields.GetLiveDocs(leftReader);
             IBits rightBits = MultiFields.GetLiveDocs(rightReader);
 
@@ -3281,7 +3281,7 @@ namespace Lucene.Net.Util
                 return;
             }
 
-            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             Assert.AreEqual(leftBits.Length, rightBits.Length, info);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
@@ -3365,7 +3365,7 @@ namespace Lucene.Net.Util
         ////        if (TempDirBase == null)
         ////        {
         ////            DirectoryInfo directory = new DirectoryInfo(System.IO.Path.GetTempPath());
-        ////            //Debugging.Assert(() => directory.Exists && directory.Directory != null && directory.CanWrite());
+        ////            //if (Debugging.AssertsEnabled) Debugging.Assert(() => directory.Exists && directory.Directory != null && directory.CanWrite());
 
         ////            RandomizedContext ctx = RandomizedContext.Current;
         ////            Type clazz = ctx.GetTargetType;
@@ -3504,7 +3504,7 @@ namespace Lucene.Net.Util
         /// </summary>
         private static void RegisterToRemoveAfterSuite(FileSystemInfo f)
         {
-            Debugging.Assert(() => f != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => f != null);
 
             if (LuceneTestCase.LeaveTemporary)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
index 50f9d60..eafb5f2 100644
--- a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
@@ -29,13 +29,13 @@ namespace Lucene.Net.Util
     {
         public override void Message(string component, string message)
         {
-            Debugging.Assert(() => component != null);
-            Debugging.Assert(() => message != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => component != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => message != null);
         }
 
         public override bool IsEnabled(string component)
         {
-            Debugging.Assert(() => component != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => component != null);
             return true; // to actually enable logging, we just ignore on message()
         }
 
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
index f3cc295..fa25854 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
@@ -56,7 +56,7 @@ namespace Lucene.Net.Util
           {
             try
             {
-              Debugging.Assert(false);
+              if (Debugging.AssertsEnabled) Debugging.Assert(false);
               string msg = "Test class requires enabled assertions, enable globally (-ea)" + " or for Solr/Lucene subpackages only: " + Description.ClassName;
               Console.Error.WriteLine(msg);
               throw new Exception(msg);
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
index eaf6433..f32b343 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
@@ -169,7 +169,7 @@ namespace Lucene.Net.Util
                                                                 !ShouldAvoidCodec("Lucene3x"))) // preflex-only setup
             {
                 codec = Codec.ForName("Lucene3x");
-                Debugging.Assert(() => (codec is PreFlexRWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is PreFlexRWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
             }
             else if ("Lucene40".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
@@ -179,8 +179,8 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene40");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debugging.Assert(() => (codec is Lucene40RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
-                Debugging.Assert(() => (PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), () => "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene40RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), () => "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene41".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -190,7 +190,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene41");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debugging.Assert(() => (codec is Lucene41RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene41RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene42".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -200,7 +200,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene42");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debugging.Assert(() => (codec is Lucene42RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene42RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene45".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -210,7 +210,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene45");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debugging.Assert(() => (codec is Lucene45RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene45RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if (("random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) == false) 
                 || ("random".Equals(LuceneTestCase.TestDocValuesFormat, StringComparison.Ordinal) == false))
@@ -275,7 +275,7 @@ namespace Lucene.Net.Util
             }
             else
             {
-                Debugging.Assert(() => false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
             }
             Codec.Default = codec;
 
diff --git a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
index 1a8b2a1..9730e3f 100644
--- a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
+++ b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Util
 
         public ThrottledIndexOutput(int bytesPerSecond, long flushDelayMillis, long closeDelayMillis, long seekDelayMillis, long minBytesWritten, IndexOutput @delegate)
         {
-            Debugging.Assert(() => bytesPerSecond > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => bytesPerSecond > 0);
             this.@delegate = @delegate;
             this.bytesPerSecond = bytesPerSecond;
             this.flushDelayMillis = flushDelayMillis;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
index f398ac1..f0b5623 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
@@ -422,7 +422,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 // Same length: no change to offset
                             }
 
-                            Debugging.Assert(() => inputOffsets.Count == output.Length, () => "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputOffsets.Count == output.Length, () => "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
                         }
                         else
                         {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
index e48cafa..6333c35 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
@@ -211,7 +211,7 @@ namespace Lucene.Net.Analysis.Core
 
             internal FactoryAnalyzer(TokenizerFactory tokenizer, TokenFilterFactory tokenfilter, CharFilterFactory charFilter)
             {
-                Debugging.Assert(() => tokenizer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => tokenizer != null);
                 this.tokenizer = tokenizer;
                 this.charFilter = charFilter;
                 this.tokenfilter = tokenfilter;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
index 4f66f90..20ea9ce 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
@@ -172,7 +172,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                Debugging.Assert(() => args.Length == 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
@@ -185,7 +185,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                Debugging.Assert(() => args.Length == 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
index b8158af..48f9ea8 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
@@ -168,16 +168,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                Debugging.Assert(() => f.Exists);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        Debugging.Assert(() => dicEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        Debugging.Assert(() => affEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -208,16 +208,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    Debugging.Assert(() => f.Exists);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            Debugging.Assert(() => dicEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            Debugging.Assert(() => affEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
index e6c2d97..cce39a6 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
@@ -184,16 +184,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                Debugging.Assert(() => f.Exists);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        Debugging.Assert(() => dicEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        Debugging.Assert(() => affEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -226,16 +226,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    Debugging.Assert(() => f.Exists);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            Debugging.Assert(() => dicEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            Debugging.Assert(() => affEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
index 4ec4e7d..44f4ad2 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
@@ -268,7 +268,7 @@ namespace Lucene.Net.Analysis.Synonym
 
         private string GetRandomString(char start, int alphabetSize, int length)
         {
-            Debugging.Assert(() => alphabetSize <= 26);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => alphabetSize <= 26);
             char[] s = new char[2 * length];
             for (int charIDX = 0; charIDX < length; charIDX++)
             {
diff --git a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
index 7c7a4ef..5c1afbf 100644
--- a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
+++ b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
@@ -154,7 +154,7 @@ namespace Lucene.Net.Facet
                     if (numInRow > 1)
                     {
                         Array.Sort(labelValues, i - numInRow, i - (i - numInRow), Comparer<LabelAndValue>.Create((a,b)=> {
-                            Debugging.Assert(() => (double)a.Value == (double)b.Value);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => (double)a.Value == (double)b.Value);
                             return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label));
                         }));
                     }
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index a28559c..a9d27ab 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -1197,7 +1197,7 @@ namespace Lucene.Net.Facet.Range
 
             protected override Facets BuildFacetsResult(FacetsCollector drillDowns, FacetsCollector[] drillSideways, string[] drillSidewaysDims)
             {
-                Debugging.Assert(() => drillSideways.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => drillSideways.Length == 1);
                 return new DoubleRangeFacetCounts("field", vs, drillSideways[0], fastMatchFilter, ranges);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
index 6e8be41..09c2ed7 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
@@ -385,7 +385,7 @@ namespace Lucene.Net.Facet.Taxonomy
             public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
             {
                 Scorer scorer = (Scorer)context["scorer"];
-                Debugging.Assert(() => scorer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => scorer != null);
                 return new DoubleDocValuesAnonymousInnerClassHelper(this, scorer);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
index 115a120..d89256a 100644
--- a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
+++ b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
@@ -866,7 +866,7 @@ namespace Lucene.Net.Facet
 
             public virtual void Collect(int doc)
             {
-                Debugging.Assert(() => doc > lastDocID);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc > lastDocID);
                 lastDocID = doc;
             }
 
@@ -948,8 +948,8 @@ namespace Lucene.Net.Facet
 
             public virtual void Inc(int[] dims, int[] dims2, int onlyDim)
             {
-                Debugging.Assert(() => dims.Length == counts.Length);
-                Debugging.Assert(() => dims2.Length == counts.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => dims.Length == counts.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => dims2.Length == counts.Length);
                 for (int dim = 0; dim < dims.Length; dim++)
                 {
                     if (onlyDim == -1 || dim == onlyDim)
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index faa1519..3329b69 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -559,7 +559,7 @@ namespace Lucene.Net.Search.Grouping
             Field[] facetFields;
             if (useDv)
             {
-                Debugging.Assert(() => !multipleFacetValuesPerDocument);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !multipleFacetValuesPerDocument);
                 facetFields = new Field[2];
                 facetFields[0] = NewStringField("facet", "", Field.Store.NO);
                 doc.Add(facetFields[0]);
@@ -816,7 +816,7 @@ namespace Lucene.Net.Search.Grouping
         {
             BytesRef facetPrefixBR = facetPrefix == null ? null : new BytesRef(facetPrefix);
             // DocValues cannot be multi-valued:
-            Debugging.Assert(() => !multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => !multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
             return TermGroupFacetCollector.CreateTermGroupFacetCollector(groupField, facetField, multipleFacetsPerDocument, facetPrefixBR, Random.nextInt(1024));
         }
 
diff --git a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
index 859bff4..99189a1 100644
--- a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
+++ b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
@@ -775,8 +775,8 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             protected override IList<string[]> LoadFieldValues(IndexSearcher searcher, string[] fields, int[] docids, int maxLength)
             {
-                Debugging.Assert(() => fields.Length == 1);
-                Debugging.Assert(() => docids.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docids.Length == 1);
                 String[][] contents = RectangularArrays.ReturnRectangularArray<string>(1, 1); //= new String[1][1];
                 contents[0][0] = text;
                 return contents;
@@ -1179,7 +1179,7 @@ namespace Lucene.Net.Search.PostingsHighlight
         {
             protected override char GetMultiValuedSeparator(string field)
             {
-                Debugging.Assert(() => field.Equals("body", StringComparison.Ordinal));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Equals("body", StringComparison.Ordinal));
                 return '\u2029';
             }
         }
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index f79246d..09ea77f 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -1030,7 +1030,7 @@ namespace Lucene.Net.Tests.Join
                     {
                         DocsEnum docsEnum = MultiFields.GetTermDocsEnum(topLevelReader,
                             MultiFields.GetLiveDocs(topLevelReader), "id", new BytesRef(otherSideDoc.id), 0);
-                        Debugging.Assert(() => docsEnum != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => docsEnum != null);
                         int doc = docsEnum.NextDoc();
                         expectedResult.Set(doc);
                     }
diff --git a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
index 10bffe2..32a1bce 100644
--- a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
@@ -65,8 +65,8 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override Query GetQuery(string query, ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
-            Debugging.Assert(() => cqpC is QueryParser, () => "Parameter must be instance of QueryParser");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser, () => "Parameter must be instance of QueryParser");
             QueryParser qp = (QueryParser)cqpC;
             return qp.Parse(query);
         }
@@ -83,35 +83,35 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.OR;
         }
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.AND;
         }
 
         public override void SetAnalyzeRangeTerms(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AnalyzeRangeTerms = (value);
         }
 
         public override void SetAutoGeneratePhraseQueries(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AutoGeneratePhraseQueries = value;
         }
 
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC, string field, DateTools.Resolution value)
         {
-            Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.SetDateResolution(field, value);
         }
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
index c336603..f9d2855 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
@@ -59,8 +59,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override Query GetQuery(String query, ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
-            Debugging.Assert(() => (cqpC is StandardQueryParser), () => "Parameter must be instance of StandardQueryParser");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => (cqpC is StandardQueryParser), () => "Parameter must be instance of StandardQueryParser");
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             return Parse(query, qp);
         }
@@ -80,7 +80,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.OR);
         }
@@ -88,7 +88,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.AND);
         }
@@ -111,7 +111,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC,
             string field, DateTools.Resolution value)
         {
-            Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DateResolutionMap.Put(field, value);
         }
diff --git a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
index b41b01a..a6fe124 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
@@ -461,7 +461,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
index 3c158bf..ee05bc1 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
@@ -367,7 +367,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
index b57d7fa..6f54dd4 100644
--- a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
+++ b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
@@ -152,7 +152,7 @@ namespace Lucene.Net.Spatial
 
         private double randomGaussianMinMeanMax(double min, double mean, double max)
         {
-            Debugging.Assert(() => mean > min);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => mean > min);
             return randomGaussianMeanMax(mean - min, max - min) + min;
         }
 
@@ -166,7 +166,7 @@ namespace Lucene.Net.Spatial
         private double randomGaussianMeanMax(double mean, double max)
         {
             // DWS: I verified the results empirically
-            Debugging.Assert(() => mean <= max && mean >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => mean <= max && mean >= 0);
             double g = randomGaussian();
             double mean2 = mean;
             double flip = 1;
@@ -180,7 +180,7 @@ namespace Lucene.Net.Spatial
             // 1 standard deviation alters the calculation
             double pivotMax = max - mean2;
             double pivot = Math.Min(mean2, pivotMax / 2);//from 0 to max-mean2
-            Debugging.Assert(() => pivot >= 0 && pivotMax >= pivot && g >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => pivot >= 0 && pivotMax >= pivot && g >= 0);
             double pivotResult;
             if (g <= 1)
                 pivotResult = pivot * g;
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
index 016b78e..4b7301d 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
@@ -651,7 +651,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                     return 0;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
index 5951a30..4857d73 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
@@ -603,7 +603,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                     return 0;
                 }
             }
@@ -1313,7 +1313,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 else
                 {
                     int c = CHARSEQUENCE_COMPARER.Compare(a.Key, b.Key);
-                    Debugging.Assert(() => c != 0, () => "term=" + a.Key);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => c != 0, () => "term=" + a.Key);
                     return c;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
index 2f160a6..0780c82 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
@@ -680,7 +680,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     return tokens[k];
                 }
             }
-            Debugging.Assert(() => false);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
             return null;
         }
 
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
index d835cf9..14251e7 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Search.Suggest
 
         public override void SetUp()
         {
-            Debugging.Assert(() => false, () => "disable assertions before running benchmarks!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "disable assertions before running benchmarks!");
             IList<Input> input = ReadTop50KWiki();
             input.Shuffle(Random);
             dictionaryInput = input.ToArray();
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Suggest
             List<Input> input = new List<Input>();
 
             var resource = typeof(LookupBenchmarkTest).FindAndGetManifestResourceStream("Top50KWiki.utf8");
-            Debugging.Assert(() => resource != null, () => "Resource missing: Top50KWiki.utf8");
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => resource != null, () => "Resource missing: Top50KWiki.utf8");
 
             string line = null;
             using (TextReader br = new StreamReader(resource, UTF_8))
diff --git a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
index 8aaa6b9..1322b74 100644
--- a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis
                     pos += minPosLength;
                     offset = 2 * pos;
                 }
-                Debugging.Assert(() => maxPos <= pos, () => "input string mal-formed: posLength>1 tokens hang over the end");
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => maxPos <= pos, () => "input string mal-formed: posLength>1 tokens hang over the end");
             }
         }
 
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
index 6a2347d..40b002f 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
@@ -296,7 +296,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// </summary>
         public virtual void AssertTermsStatistics(Terms leftTerms, Terms rightTerms)
         {
-            Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount);
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
index 42a0bd8..0a2e89e 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
@@ -113,7 +113,7 @@ namespace Lucene.Net.Codecs.PerField
             {
                 Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                 Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                Debugging.Assert(() => ireader.Leaves.Count == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
                 NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv1");
                 Assert.AreEqual(5, dv.Get(hits.ScoreDocs[i].Doc));
                 BinaryDocValues dv2 = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv2");
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
index a82465a..2ed15aa 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
@@ -434,7 +434,7 @@ namespace Lucene.Net.Index
             // true if this is a 4.2+ index
             bool is42Index = MultiFields.GetMergedFieldInfos(reader).FieldInfo("dvSortedSet") != null;
 
-            Debugging.Assert(() => is40Index); // NOTE: currently we can only do this on trunk!
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => is40Index); // NOTE: currently we can only do this on trunk!
 
             IBits liveDocs = MultiFields.GetLiveDocs(reader);
 
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
index 8fd5b72..417df93 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
@@ -1039,7 +1039,7 @@ namespace Lucene.Net.Index
             Assert.AreEqual(1, td.TotalHits);
             AtomicReader wrapper = SlowCompositeReaderWrapper.Wrap(ir);
             DocsAndPositionsEnum de = wrapper.GetTermPositionsEnum(new Term("field3", "broken"));
-            Debugging.Assert(() => de != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => de != null);
             Assert.AreEqual(0, de.NextDoc());
             Assert.AreEqual(0, de.NextPosition());
             ir.Dispose();
diff --git a/src/Lucene.Net.Tests/Index/TestCodecs.cs b/src/Lucene.Net.Tests/Index/TestCodecs.cs
index 2b7fbe3..2888663 100644
--- a/src/Lucene.Net.Tests/Index/TestCodecs.cs
+++ b/src/Lucene.Net.Tests/Index/TestCodecs.cs
@@ -446,7 +446,7 @@ namespace Lucene.Net.Index
                     for (int i = 0; i < NUM_TEST_THREADS - 1; i++)
                     {
                         threads[i].Join();
-                        Debugging.Assert(() => !threads[i].failed);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !threads[i].failed);
                     }
 
                 }
@@ -759,14 +759,14 @@ namespace Lucene.Net.Index
                                         if (doc == DocIdSetIterator.NO_MORE_DOCS)
                                         {
                                             // skipped past last doc
-                                            Debugging.Assert(() => upto2 == term2.docs.Length - 1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto2 == term2.docs.Length - 1);
                                             ended = true;
                                             break;
                                         }
                                         else
                                         {
                                             // skipped to next doc
-                                            Debugging.Assert(() => upto2 < term2.docs.Length - 1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto2 < term2.docs.Length - 1);
                                             if (doc >= term2.docs[1 + upto2])
                                             {
                                                 upto2++;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
index e195ed4..a2517f5 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
@@ -2140,14 +2140,14 @@ namespace Lucene.Net.Index
             r = w.GetReader();
             long version2 = r.Version;
             r.Dispose();
-            Debugging.Assert(() => version2 > version);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => version2 > version);
 
             w.DeleteDocuments(new Term("id", "0"));
             r = w.GetReader();
             w.Dispose();
             long version3 = r.Version;
             r.Dispose();
-            Debugging.Assert(() => version3 > version2);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => version3 > version2);
             d.Dispose();
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
index a48d954..ffdcfdd 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
@@ -315,7 +315,7 @@ namespace Lucene.Net.Index
                         }
                         for (int i = 0; i < merge.Segments.Count; i++)
                         {
-                            Debugging.Assert(() => merge.Segments[i].Info.DocCount < 20);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => merge.Segments[i].Info.DocCount < 20);
                         }
                         writer.Merge(merge);
                     }
diff --git a/src/Lucene.Net.Tests/Index/TestIndexableField.cs b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
index b71cdf2..4308d1a 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexableField.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
@@ -317,7 +317,7 @@ namespace Lucene.Net.Index
                         }
                         else
                         {
-                            Debugging.Assert(() => stringValue != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => stringValue != null);
                             Assert.AreEqual(stringValue, f.GetStringValue());
                         }
                     }
@@ -424,7 +424,7 @@ namespace Lucene.Net.Index
                         return false;
                     }
 
-                    Debugging.Assert(() => fieldUpto < outerInstance.fieldCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldUpto < outerInstance.fieldCount);
                     if (fieldUpto == 0)
                     {
                         fieldUpto = 1;
diff --git a/src/Lucene.Net.Tests/Index/TestLongPostings.cs b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
index 118fcaa..c9859d7 100644
--- a/src/Lucene.Net.Tests/Index/TestLongPostings.cs
+++ b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
@@ -462,9 +462,9 @@ namespace Lucene.Net.Index
                 else
                 {
                     docs = postings = TestUtil.Docs(Random, r, "field", new BytesRef(term), null, null, DocsFlags.FREQS);
-                    Debugging.Assert(() => postings != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => postings != null);
                 }
-                Debugging.Assert(() => docs != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docs != null);
 
                 int docID = -1;
                 while (docID < DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
index e2a79c0..5dfadbf 100644
--- a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
 
         protected override Directory GetDirectory(Directory @in)
         {
-            Debugging.Assert(() => @in is MockDirectoryWrapper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in is MockDirectoryWrapper);
             if (!useNonNrtReaders)
             {
                 ((MockDirectoryWrapper)@in).AssertNoDeleteOpenFile = true;
diff --git a/src/Lucene.Net.Tests/Index/TestPayloads.cs b/src/Lucene.Net.Tests/Index/TestPayloads.cs
index 0f208af..2129822 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloads.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloads.cs
@@ -310,7 +310,7 @@ namespace Lucene.Net.Index
             // this test needs the random data to be valid unicode
             string s = TestUtil.RandomFixedByteLengthUnicodeString(Random, data.Length);
             var b = s.GetBytes(utf8);
-            Debugging.Assert(() => b.Length == data.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => b.Length == data.Length);
             System.Buffer.BlockCopy(b, 0, data, 0, b.Length);
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
index 5b7e149..f38c941 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Index
 
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(1, "field");
-            Debugging.Assert(() => terms != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
@@ -128,7 +128,7 @@ namespace Lucene.Net.Index
             writer.AddDocument(doc);
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(0, "field");
-            Debugging.Assert(() => terms != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
diff --git a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
index c621f33..6e96835 100644
--- a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
@@ -177,9 +177,9 @@ namespace Lucene.Net.Index
                     {
                         dp.NextPosition();
                         int start = dp.StartOffset;
-                        Debugging.Assert(() => start >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0);
                         int end = dp.EndOffset;
-                        Debugging.Assert(() => end >= 0 && end >= start);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= 0 && end >= start);
                         // check that the offsets correspond to the term in the src text
                         Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals(term, StringComparison.Ordinal));
                         if (withPayloads)
@@ -208,9 +208,9 @@ namespace Lucene.Net.Index
                     string storedNumbers = reader.Document(doc).Get("numbers");
                     dp.NextPosition();
                     int start = dp.StartOffset;
-                    Debugging.Assert(() => start >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0);
                     int end = dp.EndOffset;
-                    Debugging.Assert(() => end >= 0 && end >= start);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= 0 && end >= start);
                     // check that the offsets correspond to the term in the src text
                     Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals("hundred", StringComparison.Ordinal));
                     if (withPayloads)
diff --git a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
index aa7f52f..b7d7a3c 100644
--- a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
@@ -347,7 +347,7 @@ namespace Lucene.Net.Index
             }
             if (r1.NumDocs != r2.NumDocs)
             {
-                Debugging.Assert(() => false, () => "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
             }
             bool hasDeletes = !(r1.MaxDoc == r2.MaxDoc && r1.NumDocs == r1.MaxDoc);
 
@@ -682,7 +682,7 @@ namespace Lucene.Net.Index
                 IIndexableField f2 = ff2[i];
                 if (f1.GetBinaryValue() != null)
                 {
-                    Debugging.Assert(() => f2.GetBinaryValue() != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f2.GetBinaryValue() != null);
                 }
                 else
                 {
diff --git a/src/Lucene.Net.Tests/Index/TestStressNRT.cs b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
index ef4f795..3154b56 100644
--- a/src/Lucene.Net.Tests/Index/TestStressNRT.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
@@ -263,8 +263,8 @@ namespace Lucene.Net.Index
                                 {
                                     // install the new reader if it's newest (and check the current version since another reader may have already been installed)
                                     //System.out.println(Thread.currentThread().getName() + ": newVersion=" + newReader.getVersion());
-                                    Debugging.Assert(() => newReader.RefCount > 0);
-                                    Debugging.Assert(() => outerInstance.reader.RefCount > 0);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => newReader.RefCount > 0);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.reader.RefCount > 0);
                                     if (newReader.Version > outerInstance.reader.Version)
                                     {
                                         if (Verbose)
diff --git a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
index def59ed..d8dada1 100644
--- a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
@@ -829,7 +829,7 @@ namespace Lucene.Net.Index
                     }
                     else
                     {
-                        Debugging.Assert(() => loc >= -validTerms.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => loc >= -validTerms.Length);
                         Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, result);
                     }
                 }
diff --git a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
index e8f5f73..bd1216b 100644
--- a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
+++ b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search.Spans
             }
 
             int subIndex = ReaderUtil.SubIndex(target, leaves);
-            Debugging.Assert(() => subIndex >= leafOrd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => subIndex >= leafOrd);
             if (subIndex != leafOrd)
             {
                 AtomicReaderContext ctx = leaves[subIndex];
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
index d203efb..b870992 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
@@ -119,7 +119,7 @@ namespace Lucene.Net.Search
 
             public override bool Score(ICollector c, int maxDoc)
             {
-                Debugging.Assert(() => doc == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == -1);
                 doc = 3000;
                 FakeScorer fs = new FakeScorer();
                 fs.doc = doc;
diff --git a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
index a2aa38e..8a244a0 100644
--- a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
@@ -234,7 +234,7 @@ namespace Lucene.Net.Search
 
             Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random, new TermQuery(new Term("field", "a"))));
             IndexSearcher s = NewSearcher(r);
-            Debugging.Assert(() => s is AssertingIndexSearcher);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => s is AssertingIndexSearcher);
             // this used to fail
             s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
 
diff --git a/src/Lucene.Net.Tests/Search/TestFieldCache.cs b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
index 3358372..7295a56 100644
--- a/src/Lucene.Net.Tests/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
@@ -372,7 +372,7 @@ namespace Lucene.Net.Search
                         break;
                     }
                     long ord = termOrds.NextOrd();
-                    Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
                     BytesRef scratch = new BytesRef();
                     termOrds.LookupOrd(ord, scratch);
                     Assert.AreEqual(v, scratch);
diff --git a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
index 6157c9a..de9b7be 100644
--- a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
+++ b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
@@ -365,14 +365,14 @@ namespace Lucene.Net.Search
                 this.sims = new SimScorer[(int)dv.ValueCount];
                 foreach (BooleanClause clause in bq.GetClauses())
                 {
-                    Debugging.Assert(() => !clause.IsProhibited);
-                    Debugging.Assert(() => !clause.IsRequired);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !clause.IsProhibited);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !clause.IsRequired);
                     Term term = ((TermQuery)clause.Query).Term;
                     long ord = dv.LookupTerm(term.Bytes);
                     if (ord >= 0)
                     {
                         bool success = ords.Add(ord);
-                        Debugging.Assert(() => success); // no dups
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => success); // no dups
                         TermContext context = TermContext.Build(reader.Context, term);
                         SimWeight w = weight.Similarity.ComputeWeight(1f, searcher.CollectionStatistics("field"), searcher.TermStatistics(term, context));
                         var dummy = w.GetValueForNormalization(); // ignored
@@ -384,7 +384,7 @@ namespace Lucene.Net.Search
 
             public override float GetScore()
             {
-                Debugging.Assert(() => score != 0, currentMatched.ToString);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => score != 0, currentMatched.ToString);
                 return (float)score * ((BooleanWeight)m_weight).Coord(currentMatched, ((BooleanWeight)m_weight).MaxCoord);
             }
 
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
 
             public override int NextDoc()
             {
-                Debugging.Assert(() => currentDoc != NO_MORE_DOCS);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentDoc != NO_MORE_DOCS);
                 for (currentDoc = currentDoc + 1; currentDoc < maxDoc; currentDoc++)
                 {
                     currentMatched = 0;
diff --git a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
index f6c0ac7..d1e61d8 100644
--- a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
+++ b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
@@ -223,7 +223,7 @@ namespace Lucene.Net.Search
             foreach (string field in vectors)
             {
                 Terms terms = vectors.GetTerms(field);
-                Debugging.Assert(() => terms != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
                 VerifyVector(terms.GetIterator(null), num);
             }
         }
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
index a7dc07e..050e28c 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
@@ -474,13 +474,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             int lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2 * lower;
-            Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
index 4e0ad53..4262d3c 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
@@ -501,13 +501,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             long lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2L * lower;
-            Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
index 6ebd621..8118ca6 100644
--- a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
+++ b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
@@ -418,7 +418,7 @@ namespace Lucene.Net.Search
 //#endif
                 }
 
-                Debugging.Assert(() => docId >= 0, () => " base=" + docBase + " doc=" + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => docId >= 0, () => " base=" + docBase + " doc=" + doc);
                 bits.Set(docId);
                 lastDocCollected = docId;
             }
diff --git a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
index b18aaa8..5addb89 100644
--- a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
+++ b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
@@ -76,7 +76,7 @@ namespace Lucene.Net.Util.Automaton
                 nonSurrogateCount = endCode - startCode + 1 - (UnicodeUtil.UNI_SUR_LOW_END - UnicodeUtil.UNI_SUR_HIGH_START + 1);
             }
 
-            Debugging.Assert(() => nonSurrogateCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => nonSurrogateCount > 0);
 
             for (int iter = 0; iter < iters; iter++)
             {
@@ -95,8 +95,8 @@ namespace Lucene.Net.Util.Automaton
                     }
                 }
 
-                Debugging.Assert(() => code >= startCode && code <= endCode, () => "code=" + code + " start=" + startCode + " end=" + endCode);
-                Debugging.Assert(() => !IsSurrogate(code));
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => code >= startCode && code <= endCode, () => "code=" + code + " start=" + startCode + " end=" + endCode);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => !IsSurrogate(code));
 
                 Assert.IsTrue(Matches(a, code), "DFA for range " + startCode + "-" + endCode + " failed to match code=" + code);
             }
diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
index df67774..b262eda 100644
--- a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
+++ b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
@@ -571,7 +571,7 @@ namespace Lucene.Net.Util.Fst
                     long tMid = Environment.TickCount;
                     Console.WriteLine(((tMid - tStart) / 1000.0) + " sec to add all terms");
 
-                    Debugging.Assert(() => builder.TermCount == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => builder.TermCount == ord);
                     FST<T> fst = builder.Finish();
                     long tEnd = Environment.TickCount;
                     Console.WriteLine(((tEnd - tMid) / 1000.0) + " sec to finish/pack");
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
index e7cb03c..007eee8 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Util.Packed
                 {
                     doc = NO_MORE_DOCS;
                 }
-                Debugging.Assert(() => doc < numBits);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc < numBits);
                 return doc;
             }
 
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
index 35b2633..9111a35 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeAdvanceToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test advancing to multiples of m
-            Debugging.Assert(() => m > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0);
             long previousValue = -1L;
             long index = 0;
             long mm = m;
@@ -120,7 +120,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeBackToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test backing to multiples of m
-            Debugging.Assert(() => m > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0);
             efd.ToAfterSequence();
             int index = values.Length - 1;
             if (index < 0)
@@ -135,7 +135,7 @@ namespace Lucene.Net.Util.Packed
             while (index >= 0)
             {
                 expValue = values[index];
-                Debugging.Assert(() => mm < previousValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => mm < previousValue);
                 if (expValue <= mm)
                 {
                     long backValue_ = efd.BackToValue(mm);
diff --git a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
index 63a75b9..8fad1f7 100644
--- a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
+++ b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Util
                 r2.NextBytes(bytes);
                 dataOutput.WriteBytes(bytes, bytes.Length);
                 long fp = dataOutput.GetFilePointer();
-                Debugging.Assert(() => fp == lastFP + numBytes);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => fp == lastFP + numBytes);
                 lastFP = fp;
                 netBytes += numBytes;
             }
diff --git a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
index f31d3ce..3c272c7 100644
--- a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static OpenBitSet RandomOpenSet(int numBits, int numBitsSet)
         {
-            Debugging.Assert(() => numBitsSet <= numBits);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => numBitsSet <= numBits);
             OpenBitSet set = new OpenBitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/Lucene.Net/Analysis/NumericTokenStream.cs b/src/Lucene.Net/Analysis/NumericTokenStream.cs
index fbff885..ace2805 100644
--- a/src/Lucene.Net/Analysis/NumericTokenStream.cs
+++ b/src/Lucene.Net/Analysis/NumericTokenStream.cs
@@ -178,7 +178,7 @@ namespace Lucene.Net.Analysis
 
             public void FillBytesRef()
             {
-                Debugging.Assert(() => ValueSize == 64 || ValueSize == 32);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => ValueSize == 64 || ValueSize == 32);
                 if (ValueSize == 64)
                 {
                     NumericUtils.Int64ToPrefixCoded(_value, Shift, _bytes);
diff --git a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
index 93d15f2..c70f8fe 100644
--- a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
+++ b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
@@ -155,7 +155,7 @@ namespace Lucene.Net.Analysis
                 {
                     posInc = 1;
                 }
-                Debugging.Assert(() => pos > -1 || posInc > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos > -1 || posInc > 0);
 
                 if (posInc > 0)
                 {
@@ -163,7 +163,7 @@ namespace Lucene.Net.Analysis
                     pos += posInc;
 
                     posData = positions.Get(pos);
-                    Debugging.Assert(() => posData.leaving == null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => posData.leaving == null);
 
                     if (posData.arriving == null)
                     {
diff --git a/src/Lucene.Net/Analysis/Tokenizer.cs b/src/Lucene.Net/Analysis/Tokenizer.cs
index 4edf011..36acdea 100644
--- a/src/Lucene.Net/Analysis/Tokenizer.cs
+++ b/src/Lucene.Net/Analysis/Tokenizer.cs
@@ -115,7 +115,7 @@ namespace Lucene.Net.Analysis
                 throw new InvalidOperationException("TokenStream contract violation: Close() call missing");
             }
             this.inputPending = input;
-            Debugging.Assert(SetReaderTestPoint);
+            if (Debugging.AssertsEnabled) Debugging.Assert(SetReaderTestPoint);
         }
 
         public override void Reset()
diff --git a/src/Lucene.Net/Codecs/BlockTermState.cs b/src/Lucene.Net/Codecs/BlockTermState.cs
index 2816115..13a8bd7 100644
--- a/src/Lucene.Net/Codecs/BlockTermState.cs
+++ b/src/Lucene.Net/Codecs/BlockTermState.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs
 
         public override void CopyFrom(TermState other)
         {
-            Debugging.Assert(() => other is BlockTermState, () => "can not copy from " + other.GetType().Name);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => other is BlockTermState, () => "can not copy from " + other.GetType().Name);
             BlockTermState other2 = (BlockTermState)other;
             base.CopyFrom(other);
             DocFreq = other2.DocFreq;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
index 30064e4..a3f1591 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
@@ -167,13 +167,13 @@ namespace Lucene.Net.Codecs
                 {
                     int field = @in.ReadVInt32();
                     long numTerms = @in.ReadVInt64();
-                    Debugging.Assert(() => numTerms >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms >= 0);
                     int numBytes = @in.ReadVInt32();
                     BytesRef rootCode = new BytesRef(new byte[numBytes]);
                     @in.ReadBytes(rootCode.Bytes, 0, numBytes);
                     rootCode.Length = numBytes;
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
-                    Debugging.Assert(() => fieldInfo != null, () => "field=" + field);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo != null, () => "field=" + field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : @in.ReadVInt64();
                     long sumDocFreq = @in.ReadVInt64();
                     int docCount = @in.ReadVInt32();
@@ -291,7 +291,7 @@ namespace Lucene.Net.Codecs
 
         public override Terms GetTerms(string field)
         {
-            Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
             FieldReader ret;
             fields.TryGetValue(field, out ret);
             return ret;
@@ -478,7 +478,7 @@ namespace Lucene.Net.Codecs
                 }
                 endBlockCount++;
                 long otherBytes = frame.fpEnd - frame.fp - frame.suffixesReader.Length - frame.statsReader.Length;
-                Debugging.Assert(() => otherBytes > 0, () => "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => otherBytes > 0, () => "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
                 TotalBlockOtherBytes += otherBytes;
             }
 
@@ -489,9 +489,12 @@ namespace Lucene.Net.Codecs
 
             internal virtual void Finish()
             {
-                Debugging.Assert(() => startBlockCount == endBlockCount, () => "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
-                Debugging.Assert(() => TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, () => "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
-                Debugging.Assert(() => TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, () => "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
+                if (Debugging.AssertsEnabled)
+                {
+                    Debugging.Assert(() => startBlockCount == endBlockCount, () => "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
+                    Debugging.Assert(() => TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, () => "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
+                    Debugging.Assert(() => TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, () => "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
+                }
             }
 
             public override string ToString()
@@ -529,7 +532,7 @@ namespace Lucene.Net.Codecs
                             @out.AppendLine("      " + prefix.ToString().PadLeft(2, ' ') + ": " + blockCount);
                         }
                     }
-                    Debugging.Assert(() => TotalBlockCount == total);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => TotalBlockCount == total);
                 }
                 return @out.ToString();
             }
@@ -560,7 +563,7 @@ namespace Lucene.Net.Codecs
             internal FieldReader(BlockTreeTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, BytesRef rootCode, long sumTotalTermFreq, long sumDocFreq, int docCount, long indexStartFP, int longsSize, IndexInput indexIn)
             {
                 this.outerInstance = outerInstance;
-                Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
                 this.fieldInfo = fieldInfo;
                 //DEBUG = BlockTreeTermsReader.DEBUG && fieldInfo.name.Equals("id", StringComparison.Ordinal);
                 this.numTerms = numTerms;
@@ -760,7 +763,7 @@ namespace Lucene.Net.Codecs
 
                     internal void LoadNextFloorBlock()
                     {
-                        Debugging.Assert(() => numFollowFloorBlocks > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => numFollowFloorBlocks > 0);
                         //if (DEBUG) System.out.println("    loadNextFoorBlock trans=" + transitions[transitionIndex]);
 
                         do
@@ -845,7 +848,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code_ = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code_ >> 1);
-                        Debugging.Assert(() => entCount > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => entCount > 0);
                         isLastInFloor = (code_ & 1) != 0;
 
                         // term suffixes:
@@ -906,7 +909,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -917,7 +920,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -944,7 +947,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        Debugging.Assert(() => limit > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -1021,7 +1024,7 @@ namespace Lucene.Net.Codecs
 
                     FST.Arc<BytesRef> arc = outerInstance.index.GetFirstArc(arcs[0]);
                     // Empty string prefix must have an output in the index!
-                    Debugging.Assert(() => arc.IsFinal);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
 
                     // Special pushFrame since it's the first one:
                     Frame f = stack[0];
@@ -1033,7 +1036,7 @@ namespace Lucene.Net.Codecs
                     f.Load(outerInstance.rootCode);
 
                     // for assert:
-                    Debugging.Assert(() => SetSavedStartTerm(startTerm));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => SetSavedStartTerm(startTerm));
 
                     currentFrame = f;
                     if (startTerm != null)
@@ -1067,7 +1070,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    Debugging.Assert(() => stack[ord].ord == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1101,7 +1104,7 @@ namespace Lucene.Net.Codecs
                     // possible:
                     FST.Arc<BytesRef> arc = currentFrame.arc;
                     int idx = currentFrame.prefix;
-                    Debugging.Assert(() => currentFrame.suffix > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.suffix > 0);
                     BytesRef output = currentFrame.outputPrefix;
                     while (idx < f.prefix)
                     {
@@ -1110,14 +1113,14 @@ namespace Lucene.Net.Codecs
                         // case by using current arc as starting point,
                         // passed to findTargetArc
                         arc = outerInstance.index.FindTargetArc(target, arc, GetArc(1 + idx), fstReader);
-                        Debugging.Assert(() => arc != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc != null);
                         output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
                         idx++;
                     }
 
                     f.arc = arc;
                     f.outputPrefix = output;
-                    Debugging.Assert(() => arc.IsFinal);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                     f.Load(outerInstance.outerInstance.fstOutputs.Add(output, arc.NextFinalOutput));
                     return f;
                 }
@@ -1168,7 +1171,7 @@ namespace Lucene.Net.Codecs
                     for (int idx = 0; idx < currentFrame.suffix; idx++)
                     {
                         state = runAutomaton.Step(state, currentFrame.suffixBytes[currentFrame.startBytePos + idx] & 0xff);
-                        Debugging.Assert(() => state != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => state != -1);
                     }
                     return state;
                 }
@@ -1180,13 +1183,13 @@ namespace Lucene.Net.Codecs
                 private void SeekToStartTerm(BytesRef target)
                 {
                     //if (DEBUG) System.out.println("seek to startTerm=" + target.utf8ToString());
-                    Debugging.Assert(() => currentFrame.ord == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.ord == 0);
                     if (term.Length < target.Length)
                     {
                         term.Bytes = ArrayUtil.Grow(term.Bytes, target.Length);
                     }
                     FST.Arc<BytesRef> arc = arcs[0];
-                    Debugging.Assert(() => arc == currentFrame.arc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == currentFrame.arc);
 
                     for (int idx = 0; idx <= target.Length; idx++)
                     {
@@ -1264,7 +1267,7 @@ namespace Lucene.Net.Codecs
                         }
                     }
 
-                    Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
                 }
 
                 public override BytesRef Next()
@@ -1294,7 +1297,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                Debugging.Assert(() => currentFrame.lastSubFP == lastFP);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.lastSubFP == lastFP);
                                 //if (DEBUG) System.out.println("\n  frame ord=" + currentFrame.ord + " prefix=" + brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" : currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" + currentFrame.outputPrefix);
                             }
                         }
@@ -1348,7 +1351,7 @@ namespace Lucene.Net.Codecs
                             byte[] commonSuffixBytes = compiledAutomaton.CommonSuffixRef.Bytes;
 
                             int lenInPrefix = compiledAutomaton.CommonSuffixRef.Length - currentFrame.suffix;
-                            Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
                             int suffixBytesPos;
                             int commonSuffixBytesPos = 0;
 
@@ -1359,7 +1362,7 @@ namespace Lucene.Net.Codecs
                                 // test whether the prefix part matches:
                                 byte[] termBytes = term.Bytes;
                                 int termBytesPos = currentFrame.prefix - lenInPrefix;
-                                Debugging.Assert(() => termBytesPos >= 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => termBytesPos >= 0);
                                 int termBytesPosEnd = currentFrame.prefix;
                                 while (termBytesPos < termBytesPosEnd)
                                 {
@@ -1427,7 +1430,7 @@ namespace Lucene.Net.Codecs
                         {
                             CopyTerm();
                             //if (DEBUG) System.out.println("      term match to state=" + state + "; return term=" + brToString(term));
-                            Debugging.Assert(() => savedStartTerm == null || term.CompareTo(savedStartTerm) > 0, () => "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => savedStartTerm == null || term.CompareTo(savedStartTerm) > 0, () => "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
                             return term;
                         }
                         else
@@ -1531,7 +1534,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1579,7 +1582,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1614,7 +1617,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                Debugging.Assert(() => lastFP == currentFrame.lastSubFP);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => lastFP == currentFrame.lastSubFP);
                                 // if (DEBUG) {
                                 //   System.out.println("  reset validIndexPrefix=" + validIndexPrefix);
                                 // }
@@ -1654,7 +1657,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1681,7 +1684,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    Debugging.Assert(() => stack[ord].ord == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1740,7 +1743,7 @@ namespace Lucene.Net.Codecs
                             //   System.out.println("        skip rewind!");
                             // }
                         }
-                        Debugging.Assert(() => length == f.prefix);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length == f.prefix);
                     }
                     else
                     {
@@ -1786,7 +1789,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    Debugging.Assert(() => ClearEOF());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ClearEOF());
 
                     FST.Arc<BytesRef> arc;
                     int targetUpto;
@@ -1808,12 +1811,12 @@ namespace Lucene.Net.Codecs
                         // }
 
                         arc = arcs[0];
-                        Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        Debugging.Assert(() => validIndexPrefix <= term.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -1837,7 +1840,7 @@ namespace Lucene.Net.Codecs
                             //if (arc.label != (target.bytes[target.offset + targetUpto] & 0xFF)) {
                             //System.out.println("FAIL: arc.label=" + (char) arc.label + " targetLabel=" + (char) (target.bytes[target.offset + targetUpto] & 0xFF));
                             //}
-                            Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -1904,7 +1907,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            Debugging.Assert(() => term.Length == target.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Length == target.Length);
                             if (termExists)
                             {
                                 // if (DEBUG) {
@@ -1929,8 +1932,11 @@ namespace Lucene.Net.Codecs
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
 
                         // Empty string prefix must have an output (block) in the index!
-                        Debugging.Assert(() => arc.IsFinal);
-                        Debugging.Assert(() => arc.Output != null);
+                        if (Debugging.AssertsEnabled)
+                        {
+                            Debugging.Assert(() => arc.IsFinal);
+                            Debugging.Assert(() => arc.Output != null);
+                        }
 
                         // if (DEBUG) {
                         //   System.out.println("    no seek state; push root frame");
@@ -2002,7 +2008,7 @@ namespace Lucene.Net.Codecs
                             arc = nextArc;
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             // Aggregate output as we go:
-                            Debugging.Assert(() => arc.Output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2070,7 +2076,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    Debugging.Assert(ClearEOF);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF);
 
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.seekCeil seg=" + segment + " target=" + fieldInfo.name + ":" + target.utf8ToString() + " " + target + " current=" + brToString(term) + " (exists?=" + termExists + ") validIndexPrefix=  " + validIndexPrefix);
@@ -2097,12 +2103,12 @@ namespace Lucene.Net.Codecs
                         //}
 
                         arc = arcs[0];
-                        Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        Debugging.Assert(() => validIndexPrefix <= term.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -2123,7 +2129,7 @@ namespace Lucene.Net.Codecs
                                 break;
                             }
                             arc = arcs[1 + targetUpto];
-                            Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             // TOOD: we could save the outputs in local
                             // byte[][] instead of making new objs ever
                             // seek; but, often the FST doesn't have any
@@ -2192,7 +2198,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            Debugging.Assert(() => term.Length == target.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Length == target.Length);
                             if (termExists)
                             {
                                 //if (DEBUG) {
@@ -2214,8 +2220,11 @@ namespace Lucene.Net.Codecs
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
 
                         // Empty string prefix must have an output (block) in the index!
-                        Debugging.Assert(() => arc.IsFinal);
-                        Debugging.Assert(() => arc.Output != null);
+                        if (Debugging.AssertsEnabled)
+                        {
+                            Debugging.Assert(() => arc.IsFinal);
+                            Debugging.Assert(() => arc.Output != null);
+                        }
 
                         //if (DEBUG) {
                         //System.out.println("    no seek state; push root frame");
@@ -2289,7 +2298,7 @@ namespace Lucene.Net.Codecs
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             arc = nextArc;
                             // Aggregate output as we go:
-                            Debugging.Assert(() => arc.Output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2359,7 +2368,7 @@ namespace Lucene.Net.Codecs
                 //        while (true)
                 //        {
                 //            Frame f = GetFrame(ord);
-                //            Debugging.Assert(f != null);
+                //            if (Debugging.AssertsEnabled) Debugging.Assert(f != null);
                 //            BytesRef prefix = new BytesRef(term.Bytes, 0, f.Prefix);
                 //            if (f.NextEnt == -1)
                 //            {
@@ -2371,7 +2380,7 @@ namespace Lucene.Net.Codecs
                 //            }
                 //            if (OuterInstance.Index != null)
                 //            {
-                //                Debugging.Assert(!isSeekFrame || f.Arc != null, "isSeekFrame=" + isSeekFrame + " f.arc=" + f.Arc);
+                //                if (Debugging.AssertsEnabled) Debugging.Assert(!isSeekFrame || f.Arc != null, "isSeekFrame=" + isSeekFrame + " f.arc=" + f.Arc);
                 //                if (f.Prefix > 0 && isSeekFrame && f.Arc.Label != (term.Bytes[f.Prefix - 1] & 0xFF))
                 //                {
                 //                    @out.println("      broken seek state: arc.label=" + (char)f.Arc.Label + " vs term byte=" + (char)(term.Bytes[f.Prefix - 1] & 0xFF));
@@ -2422,7 +2431,7 @@ namespace Lucene.Net.Codecs
                         {
                             arc = outerInstance.index.GetFirstArc(arcs[0]);
                             // Empty string prefix must have an output in the index!
-                            Debugging.Assert(() => arc.IsFinal);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
                         }
                         else
                         {
@@ -2434,7 +2443,7 @@ namespace Lucene.Net.Codecs
 
                     targetBeforeCurrentLength = currentFrame.ord;
 
-                    Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.next seg=" + segment + " term=" + brToString(term) + " termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);
                     //printSeekState();
@@ -2450,7 +2459,7 @@ namespace Lucene.Net.Codecs
                         // works properly:
                         //if (DEBUG) System.out.println("  re-seek to pending term=" + term.utf8ToString() + " " + term);
                         bool result = SeekExact(term);
-                        Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
                     }
 
                     // Pop finished blocks
@@ -2466,7 +2475,7 @@ namespace Lucene.Net.Codecs
                             if (currentFrame.ord == 0)
                             {
                                 //if (DEBUG) System.out.println("  return null");
-                                Debugging.Assert(SetEOF);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(SetEOF);
                                 term.Length = 0;
                                 validIndexPrefix = 0;
                                 currentFrame.Rewind();
@@ -2520,7 +2529,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                         return term;
                     }
                 }
@@ -2529,7 +2538,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                         //if (DEBUG) System.out.println("BTR.docFreq");
                         currentFrame.DecodeMetaData();
                         //if (DEBUG) System.out.println("  return " + currentFrame.state.docFreq);
@@ -2541,7 +2550,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                         currentFrame.DecodeMetaData();
                         return currentFrame.state.TotalTermFreq;
                     }
@@ -2549,7 +2558,7 @@ namespace Lucene.Net.Codecs
 
                 public override DocsEnum Docs(IBits skipDocs, DocsEnum reuse, DocsFlags flags)
                 {
-                    Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                     //if (DEBUG) {
                     //System.out.println("BTTR.docs seg=" + segment);
                     //}
@@ -2568,7 +2577,7 @@ namespace Lucene.Net.Codecs
                         return null;
                     }
 
-                    Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                     currentFrame.DecodeMetaData();
                     return outerInstance.outerInstance.postingsReader.DocsAndPositions(outerInstance.fieldInfo, currentFrame.state, skipDocs, reuse, flags);
                 }
@@ -2578,15 +2587,15 @@ namespace Lucene.Net.Codecs
                     // if (DEBUG) {
                     //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
                     // }
-                    Debugging.Assert(ClearEOF);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF);
                     if (target.CompareTo(term) != 0 || !termExists)
                     {
-                        Debugging.Assert(() => otherState != null && otherState is BlockTermState);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => otherState != null && otherState is BlockTermState);
                         currentFrame = staticFrame;
                         currentFrame.state.CopyFrom(otherState);
                         term.CopyBytes(target);
                         currentFrame.metaDataUpto = currentFrame.TermBlockOrd;
-                        Debugging.Assert(() => currentFrame.metaDataUpto > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.metaDataUpto > 0);
                         validIndexPrefix = 0;
                     }
                     else
@@ -2599,7 +2608,7 @@ namespace Lucene.Net.Codecs
 
                 public override TermState GetTermState()
                 {
-                    Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
                     currentFrame.DecodeMetaData();
                     TermState ts = (TermState)currentFrame.state.Clone();
                     //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
@@ -2731,7 +2740,7 @@ namespace Lucene.Net.Codecs
                         //if (DEBUG) {
                         //System.out.println("    loadNextFloorBlock fp=" + fp + " fpEnd=" + fpEnd);
                         //}
-                        Debugging.Assert(() => arc == null || isFloor, () => "arc=" + arc + " isFloor=" + isFloor);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == null || isFloor, () => "arc=" + arc + " isFloor=" + isFloor);
                         fp = fpEnd;
                         nextEnt = -1;
                         LoadBlock();
@@ -2765,9 +2774,9 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code >> 1);
-                        Debugging.Assert(() => entCount > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => entCount > 0);
                         isLastInFloor = (code & 1) != 0;
-                        Debugging.Assert(() => arc == null || (isLastInFloor || isFloor));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == null || (isLastInFloor || isFloor));
 
                         // TODO: if suffixes were stored in random-access
                         // array structure, then we could do binary search
@@ -2888,7 +2897,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -2906,7 +2915,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -2965,7 +2974,7 @@ namespace Lucene.Net.Codecs
                             return;
                         }
 
-                        Debugging.Assert(() => numFollowFloorBlocks != 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => numFollowFloorBlocks != 0);
 
                         long newFP = fpOrig;
                         while (true)
@@ -3025,7 +3034,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        Debugging.Assert(() => limit > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -3081,7 +3090,7 @@ namespace Lucene.Net.Codecs
                     /// </summary>
                     public void ScanToSubBlock(long subFP)
                     {
-                        Debugging.Assert(() => !isLeafBlock);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !isLeafBlock);
                         //if (DEBUG) System.out.println("  scanToSubBlock fp=" + fp + " subFP=" + subFP + " entCount=" + entCount + " lastSubFP=" + lastSubFP);
                         //assert nextEnt == 0;
                         if (lastSubFP == subFP)
@@ -3089,12 +3098,12 @@ namespace Lucene.Net.Codecs
                             //if (DEBUG) System.out.println("    already positioned");
                             return;
                         }
-                        Debugging.Assert(() => subFP < fp, () => "fp=" + fp + " subFP=" + subFP);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => subFP < fp, () => "fp=" + fp + " subFP=" + subFP);
                         long targetSubCode = fp - subFP;
                         //if (DEBUG) System.out.println("    targetSubCode=" + targetSubCode);
                         while (true)
                         {
-                            Debugging.Assert(() => nextEnt < entCount);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt < entCount);
                             nextEnt++;
                             int code = suffixesReader.ReadVInt32();
                             suffixesReader.SkipBytes(isLeafBlock ? code : (int)((uint)code >> 1));
@@ -3133,7 +3142,7 @@ namespace Lucene.Net.Codecs
                     {
                         // if (DEBUG) System.out.println("    scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        Debugging.Assert(() => nextEnt != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1);
 
                         outerInstance.termExists = true;
                         subCode = 0;
@@ -3147,7 +3156,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        Debugging.Assert(() => PrefixMatches(target));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3186,7 +3195,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    Debugging.Assert(() => targetPos == targetLimit);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3242,7 +3251,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    Debugging.Assert(() => outerInstance.termExists);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
@@ -3279,7 +3288,7 @@ namespace Lucene.Net.Codecs
                     {
                         //if (DEBUG) System.out.println("    scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        Debugging.Assert(() => nextEnt != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1);
 
                         if (nextEnt == entCount)
                         {
@@ -3291,7 +3300,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        Debugging.Assert(() => PrefixMatches(target));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3341,7 +3350,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    Debugging.Assert(() => targetPos == targetLimit);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3398,7 +3407,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    Debugging.Assert(() => outerInstance.termExists);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
index 2e8fc86..7f5065a 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
@@ -259,9 +259,9 @@ namespace Lucene.Net.Codecs
 
             public FieldMetaData(FieldInfo fieldInfo, BytesRef rootCode, long numTerms, long indexStartFP, long sumTotalTermFreq, long sumDocFreq, int docCount, int longsSize)
             {
-                Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
                 this.FieldInfo = fieldInfo;
-                Debugging.Assert(() => rootCode != null, () => "field=" + fieldInfo.Name + " numTerms=" + numTerms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => rootCode != null, () => "field=" + fieldInfo.Name + " numTerms=" + numTerms);
                 this.RootCode = rootCode;
                 this.IndexStartFP = indexStartFP;
                 this.NumTerms = numTerms;
@@ -368,14 +368,14 @@ namespace Lucene.Net.Codecs
         {
             //DEBUG = field.name.Equals("id", StringComparison.Ordinal);
             //if (DEBUG) System.out.println("\nBTTW.addField seg=" + segment + " field=" + field.name);
-            Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             return new TermsWriter(this, field);
         }
 
         internal static long EncodeOutput(long fp, bool hasTerms, bool isFloor)
         {
-            Debugging.Assert(() => fp < (1L << 62));
+            if (Debugging.AssertsEnabled) Debugging.Assert(() => fp < (1L << 62));
             return (fp << 2) | (uint)(hasTerms ? OUTPUT_FLAG_HAS_TERMS : 0) | (uint)(isFloor ? OUTPUT_FLAG_IS_FLOOR : 0);
         }
 
@@ -480,11 +480,11 @@ namespace Lucene.Net.Codecs
             {
                 // LUCENENET specific - we use a custom wrapper function to display floorBlocks, since
                 // it might contain garbage that cannot be converted into text.
-                Debugging.Assert(
+                if (Debugging.AssertsEnabled) Debugging.Assert(
                     () => (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
                     () => "isFloor=" + IsFloor + " floorBlocks=" + ToString(floorBlocks));
 
-                Debugging.Assert(() => scratchBytes.GetFilePointer() == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchBytes.GetFilePointer() == 0);
 
                 // TODO: try writing the leading vLong in MSB order
                 // (opposite of what Lucene does today), for better
@@ -495,12 +495,12 @@ namespace Lucene.Net.Codecs
                     scratchBytes.WriteVInt32(floorBlocks.Count);
                     foreach (PendingBlock sub in floorBlocks)
                     {
-                        Debugging.Assert(() => sub.FloorLeadByte != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => sub.FloorLeadByte != -1);
                         //if (DEBUG) {
                         //  System.out.println("    write floorLeadByte=" + Integer.toHexString(sub.floorLeadByte&0xff));
                         //}
                         scratchBytes.WriteByte((byte)(sbyte)sub.FloorLeadByte);
-                        Debugging.Assert(() => sub.Fp > Fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => sub.Fp > Fp);
                         scratchBytes.WriteVInt64((sub.Fp - Fp) << 1 | (uint)(sub.HasTerms ? 1 : 0));
                     }
                 }
@@ -508,7 +508,7 @@ namespace Lucene.Net.Codecs
                 ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton;
                 Builder<BytesRef> indexBuilder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE1, 0, 0, true, false, int.MaxValue, outputs, null, false, PackedInt32s.COMPACT, true, 15);
                 var bytes = new byte[(int)scratchBytes.GetFilePointer()];
-                Debugging.Assert(() => bytes.Length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => bytes.Length > 0);
                 scratchBytes.WriteTo(bytes, 0);
                 indexBuilder.Add(Util.ToInt32sRef(Prefix, scratchIntsRef), new BytesRef(bytes, 0, bytes.Length));
                 scratchBytes.Reset();
@@ -727,8 +727,11 @@ namespace Lucene.Net.Codecs
                                 // Suffix is 0, ie prefix 'foo' and term is
                                 // 'foo' so the term has empty string suffix
                                 // in this block
-                                Debugging.Assert(() => lastSuffixLeadLabel == -1);
-                                Debugging.Assert(() => numSubs == 0);
+                                if (Debugging.AssertsEnabled)
+                                {
+                                    Debugging.Assert(() => lastSuffixLeadLabel == -1);
+                                    Debugging.Assert(() => numSubs == 0);
+                                }
                                 suffixLeadLabel = -1;
                             }
                             else
@@ -739,7 +742,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             PendingBlock block = (PendingBlock)ent;
-                            Debugging.Assert(() => block.Prefix.Length > prefixLength);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => block.Prefix.Length > prefixLength);
                             suffixLeadLabel = block.Prefix.Bytes[block.Prefix.Offset + prefixLength] & 0xff;
                         }
 
@@ -860,7 +863,7 @@ namespace Lucene.Net.Codecs
                             //System.out.println("    = " + pendingCount);
                             pendingCount = 0;
 
-                            Debugging.Assert(() => outerInstance.minItemsInBlock == 1 || subCount > 1, () => "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.minItemsInBlock == 1 || subCount > 1, () => "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
                             subCount = 0;
                             startLabel = subBytes[sub + 1];
 
@@ -875,8 +878,11 @@ namespace Lucene.Net.Codecs
                                 // block.  NOTE that this may be too small (<
                                 // minItemsInBlock); need a true segmenter
                                 // here
-                                Debugging.Assert(() => startLabel != -1);
-                                Debugging.Assert(() => firstBlock != null);
+                                if (Debugging.AssertsEnabled)
+                                {
+                                    Debugging.Assert(() => startLabel != -1);
+                                    Debugging.Assert(() => firstBlock != null);
+                                }
                                 prevTerm.Int32s[prevTerm.Offset + prefixLength] = startLabel;
                                 //System.out.println("  final " + (numSubs-sub-1) + " subs");
                                 /*
@@ -896,7 +902,7 @@ namespace Lucene.Net.Codecs
 
                     prevTerm.Int32s[prevTerm.Offset + prefixLength] = savLabel;
 
-                    Debugging.Assert(() => firstBlock != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(() => firstBlock != null);
                     firstBlock.CompileIndex(floorBlocks, outerInstance.scratchBytes);
 
                     pending.Add(firstBlock);
@@ -925,11 +931,11 @@ namespace Lucene.Net.Codecs
             // block:
             private PendingBlock WriteBlock(Int32sRef prevTerm, int prefixLength, int indexPrefixLength, int startBackwards, int length, int futureTermCount, bool isFloor, int floorLeadByte, bool isLastInFloor)
             {
-                Debugging.Assert(() => length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => length > 0);
 
                 int start = pending.Count - startBackwards;
 
-                Debugging.Assert(() => start >= 0, () => "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0, () => "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
 
                 IList<PendingEntry> slice = pending.SubList(start, start + length);
 
@@ -988,7 +994,7 @@ namespace Lucene.Net.Codecs
                     subIndices = null;
                     foreach (PendingEntry ent in slice)
                     {
-                        Debugging.Assert(() => ent.IsTerm);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ent.IsTerm);
                         PendingTerm term = (PendingTerm)ent;
                         BlockTermState state = term.State;
                         int suffix = term.Term.Length - prefixLength;
@@ -1006,7 +1012,7 @@ namespace Lucene.Net.Codecs
                         statsWriter.WriteVInt32(state.DocFreq);
                         if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                         {
-                            Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq, () => state.TotalTermFreq + " vs " + state.DocFreq);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq, () => state.TotalTermFreq + " vs " + state.DocFreq);
                             statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                         }
 
@@ -1014,7 +1020,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                         for (int pos = 0; pos < longsSize; pos++)
                         {
-                            Debugging.Assert(() => longs[pos] >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => longs[pos] >= 0);
                             metaWriter.WriteVInt64(longs[pos]);
                         }
                         bytesWriter.WriteTo(metaWriter);
@@ -1049,7 +1055,7 @@ namespace Lucene.Net.Codecs
                             statsWriter.WriteVInt32(state.DocFreq);
                             if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                             {
-                                Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq);
                                 statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                             }
 
@@ -1065,7 +1071,7 @@ namespace Lucene.Net.Codecs
                             outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                             for (int pos = 0; pos < longsSize; pos++)
                             {
-                                Debugging.Assert(() => longs[pos] >= 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(() => longs[pos] >= 0);
                                 metaWriter.WriteVInt64(longs[pos]);
                             }
                             bytesWriter.WriteTo(metaWriter);
@@ -1079,13 +1085,13 @@ namespace Lucene.Net.Codecs
                             PendingBlock block = (PendingBlock)ent;
                             int suffix = block.Prefix.Length - prefixLength;
 
-                            Debugging.Assert(() => suffix > 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(() => suffix > 0);
... 12445 lines suppressed ...


[lucenenet] 06/13: SWEEP: Reviewed and added missing asserts and moved some assert conditions to be not run when asserts are disabled

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 447bc866fe030951e090d648d475333d2b7226a6
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Fri Aug 14 10:01:41 2020 +0700

    SWEEP: Reviewed and added missing asserts and moved some assert conditions to be not run when asserts are disabled
---
 .../Analysis/CharFilter/BaseCharFilter.cs          |  3 +-
 .../Analysis/Pt/RSLPStemmerBase.cs                 |  3 +-
 .../SimpleText/SimpleTextDocValuesReader.cs        |  6 +--
 .../SimpleText/SimpleTextFieldsReader.cs           |  3 +-
 .../SimpleText/SimpleTextTermVectorsReader.cs      | 14 +-----
 .../Index/TestFlushByRamOrCountsPolicy.cs          |  4 +-
 src/Lucene.Net/Analysis/Tokenizer.cs               |  4 +-
 src/Lucene.Net/Codecs/BlockTreeTermsReader.cs      |  7 ++-
 src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs      |  3 +-
 .../Codecs/Compressing/CompressionMode.cs          |  2 +
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs   | 11 +----
 src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs  |  2 +-
 src/Lucene.Net/Codecs/Lucene40/BitVector.cs        |  6 +--
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs   | 11 +----
 src/Lucene.Net/Index/CheckIndex.cs                 | 38 ++++++++-------
 src/Lucene.Net/Index/ConcurrentMergeScheduler.cs   |  3 +-
 src/Lucene.Net/Index/DirectoryReader.cs            |  1 -
 src/Lucene.Net/Index/DocFieldProcessor.cs          |  1 -
 src/Lucene.Net/Index/DocTermOrds.cs                |  3 +-
 src/Lucene.Net/Index/DocValuesFieldUpdates.cs      |  4 +-
 src/Lucene.Net/Index/DocumentsWriter.cs            | 22 ++++-----
 src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs |  1 -
 .../Index/DocumentsWriterFlushControl.cs           |  9 ++--
 src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs  | 12 ++---
 .../Index/DocumentsWriterPerThreadPool.cs          | 56 +++++++++++++++-------
 .../Index/DocumentsWriterStallControl.cs           | 15 +++---
 .../Index/FreqProxTermsWriterPerField.cs           |  3 +-
 src/Lucene.Net/Index/IndexFileDeleter.cs           |  6 +--
 src/Lucene.Net/Index/IndexWriter.cs                | 37 ++++----------
 src/Lucene.Net/Index/PrefixCodedTerms.cs           |  3 ++
 src/Lucene.Net/Index/ReadersAndUpdates.cs          | 17 ++++---
 src/Lucene.Net/Index/SortedDocValuesWriter.cs      |  1 +
 src/Lucene.Net/Index/SortedSetDocValuesWriter.cs   |  2 +-
 src/Lucene.Net/Index/StoredFieldsProcessor.cs      | 11 ++---
 src/Lucene.Net/Index/TermVectorsConsumer.cs        |  3 +-
 .../Index/TermVectorsConsumerPerField.cs           |  6 +--
 .../ThreadAffinityDocumentsWriterThreadPool.cs     |  6 +--
 src/Lucene.Net/Search/FieldCacheRangeFilter.cs     |  3 +-
 src/Lucene.Net/Search/FieldComparator.cs           |  4 +-
 src/Lucene.Net/Search/ReferenceManager.cs          |  4 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs       |  2 +
 src/Lucene.Net/Store/NIOFSDirectory.cs             | 13 ++---
 src/Lucene.Net/Store/SimpleFSDirectory.cs          |  4 +-
 src/Lucene.Net/Util/BroadWord.cs                   |  3 +-
 src/Lucene.Net/Util/Fst/FST.cs                     |  5 +-
 src/Lucene.Net/Util/Fst/NodeHash.cs                |  3 +-
 src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs     |  3 +-
 src/Lucene.Net/Util/Packed/PackedDataInput.cs      |  3 +-
 src/Lucene.Net/Util/Packed/PackedInts.cs           | 11 ++---
 src/Lucene.Net/Util/Packed/PackedWriter.cs         |  3 +-
 src/Lucene.Net/Util/PagedBytes.cs                  |  3 +-
 src/Lucene.Net/Util/RamUsageEstimator.cs           |  2 +-
 src/Lucene.Net/Util/RollingBuffer.cs               |  2 +
 53 files changed, 190 insertions(+), 217 deletions(-)

diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
index 420822b..bd3fa5b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
@@ -114,7 +114,8 @@ namespace Lucene.Net.Analysis.CharFilters
             }
 
             int offset = offsets[(size == 0) ? 0 : size - 1];
-            Debugging.Assert(() => size == 0 || off >= offset, () => "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
+            Debugging.Assert(() => size == 0 || off >= offset,
+                () => "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
 
             if (size == 0 || off != offsets[size - 1])
             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
index 942e6d5..f1b4d6a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
@@ -1,6 +1,7 @@
 using J2N.Collections.Generic.Extensions;
 using J2N.Text;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -304,7 +305,7 @@ namespace Lucene.Net.Analysis.Pt
             {
                 throw new Exception("Illegal Step header specified at line " /*+ r.LineNumber*/); // TODO Line number
             }
-            //Debugging.Assert(headerPattern.GetGroupNumbers().Length == 4);
+            //Debugging.Assert(() => headerPattern.GetGroupNumbers().Length == 4); // Not possible to read the number of groups that matched in .NET
             string name = matcher.Groups[1].Value;
             int min = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture);
             int type = int.Parse(matcher.Groups[3].Value, CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
index 1b53e2d..151afe8 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
@@ -85,10 +85,8 @@ namespace Lucene.Net.Codecs.SimpleText
                 ReadLine();
                 Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
 
-                var dvType =
-                    (DocValuesType)
-                        Enum.Parse(typeof (DocValuesType), StripPrefix(SimpleTextDocValuesWriter.TYPE));
-
+                var dvType = (DocValuesType)Enum.Parse(typeof(DocValuesType), StripPrefix(SimpleTextDocValuesWriter.TYPE));
+                // Debugging.Assert(() => dvType != null); // LUCENENET: Not possible for an enum to be null in .NET
                 if (dvType == DocValuesType.NUMERIC)
                 {
                     ReadLine();
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
index 04f6522..a4432a8 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
@@ -159,6 +159,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override BytesRef Next()
             {
+                //Debugging.Assert(() => !ended); // LUCENENET: Ended field is never set, so this can never fail
                 var result = _fstEnum.Next();
 
                 if (result == null) return null;
@@ -317,7 +318,7 @@ namespace Lucene.Net.Codecs.SimpleText
                         Debugging.Assert(
                             () => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                             // LUCENENET TODO: This assert fails sometimes, which in turns causes _scratch.Utf8ToString() to throw an index out of range exception
-                            StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END) /*, "scratch=" + _scratch.Utf8ToString()*/);
+                            StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END), () => "scratch=" + _scratch.Utf8ToString());
 
                         if (!first && (_liveDocs == null || _liveDocs.Get(_docId)))
                         {
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
index 778219e..95abd7f 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
@@ -540,18 +540,8 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override int NextPosition()
             {
-                //Debugging.Assert((_positions != null && _nextPos < _positions.Length) ||
-                //             _startOffsets != null && _nextPos < _startOffsets.Length);
-
-                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
-                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
-                // part that is checking for an error after reading to the end of the enumerator.
-
-                // Since there is no way to turn on assertions in a release build in .NET, we are throwing an InvalidOperationException
-                // in this case, which matches the behavior of Lucene 8. See #267.
-
-                if (((_positions != null && _nextPos < _positions.Length) || _startOffsets != null && _nextPos < _startOffsets.Length) == false)
-                    throw new InvalidOperationException("Read past last position");
+                Debugging.Assert(() => (_positions != null && _nextPos < _positions.Length) ||
+                    _startOffsets != null && _nextPos < _startOffsets.Length);
 
                 if (_positions != null)
                 {
diff --git a/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs b/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
index c870dda..4bdfe89 100644
--- a/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
+++ b/src/Lucene.Net.Tests/Index/TestFlushByRamOrCountsPolicy.cs
@@ -305,9 +305,9 @@ namespace Lucene.Net.Index
             while (allActiveThreads.MoveNext())
             {
                 ThreadState next = allActiveThreads.Current;
-                if (next.DocumentsWriterPerThread != null)
+                if (next.dwpt != null)
                 {
-                    bytesUsed += next.DocumentsWriterPerThread.BytesUsed;
+                    bytesUsed += next.dwpt.BytesUsed;
                 }
             }
             Assert.AreEqual(bytesUsed, flushControl.ActiveBytes);
diff --git a/src/Lucene.Net/Analysis/Tokenizer.cs b/src/Lucene.Net/Analysis/Tokenizer.cs
index 25a136a..4edf011 100644
--- a/src/Lucene.Net/Analysis/Tokenizer.cs
+++ b/src/Lucene.Net/Analysis/Tokenizer.cs
@@ -1,5 +1,5 @@
+using Lucene.Net.Diagnostics;
 using System;
-using System.Diagnostics;
 using System.IO;
 
 namespace Lucene.Net.Analysis
@@ -115,7 +115,7 @@ namespace Lucene.Net.Analysis
                 throw new InvalidOperationException("TokenStream contract violation: Close() call missing");
             }
             this.inputPending = input;
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) SetReaderTestPoint();
+            Debugging.Assert(SetReaderTestPoint);
         }
 
         public override void Reset()
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
index 2be0607..30064e4 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
@@ -4,7 +4,6 @@ using Lucene.Net.Support;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Text;
 using JCG = J2N.Collections.Generic;
@@ -29,7 +28,6 @@ namespace Lucene.Net.Codecs
      */
 
     using ArrayUtil = Lucene.Net.Util.ArrayUtil;
-    using IBits = Lucene.Net.Util.IBits;
     using ByteArrayDataInput = Lucene.Net.Store.ByteArrayDataInput;
     using ByteSequenceOutputs = Lucene.Net.Util.Fst.ByteSequenceOutputs;
     using BytesRef = Lucene.Net.Util.BytesRef;
@@ -40,6 +38,7 @@ namespace Lucene.Net.Codecs
     using DocsEnum = Lucene.Net.Index.DocsEnum;
     using FieldInfo = Lucene.Net.Index.FieldInfo;
     using FieldInfos = Lucene.Net.Index.FieldInfos;
+    using IBits = Lucene.Net.Util.IBits;
     using IndexFileNames = Lucene.Net.Index.IndexFileNames;
     using IndexInput = Lucene.Net.Store.IndexInput;
     using IndexOptions = Lucene.Net.Index.IndexOptions;
@@ -2467,7 +2466,7 @@ namespace Lucene.Net.Codecs
                             if (currentFrame.ord == 0)
                             {
                                 //if (DEBUG) System.out.println("  return null");
-                                Debugging.Assert(() => SetEOF());
+                                Debugging.Assert(SetEOF);
                                 term.Length = 0;
                                 validIndexPrefix = 0;
                                 currentFrame.Rewind();
@@ -2579,7 +2578,7 @@ namespace Lucene.Net.Codecs
                     // if (DEBUG) {
                     //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
                     // }
-                    Debugging.Assert(() => ClearEOF());
+                    Debugging.Assert(ClearEOF);
                     if (target.CompareTo(term) != 0 || !termExists)
                     {
                         Debugging.Assert(() => otherState != null && otherState is BlockTermState);
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
index 424bd4e..2e8fc86 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
@@ -479,8 +479,7 @@ namespace Lucene.Net.Codecs
             public void CompileIndex(IList<PendingBlock> floorBlocks, RAMOutputStream scratchBytes)
             {
                 // LUCENENET specific - we use a custom wrapper function to display floorBlocks, since
-                // it might contain garbage that cannot be converted into text. This is compiled out
-                // of the relese, though.
+                // it might contain garbage that cannot be converted into text.
                 Debugging.Assert(
                     () => (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
                     () => "isFloor=" + IsFloor + " floorBlocks=" + ToString(floorBlocks));
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
index 5ca2019..fe3e226 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
@@ -261,6 +261,8 @@ namespace Lucene.Net.Codecs.Compressing
 
             public override void Compress(byte[] bytes, int off, int len, DataOutput output)
             {
+                // LUCENENET specific - since DeflateStream works a bit differently than Java's Deflate class,
+                // we are unable to assert the total count
                 byte[] resultArray = null;
                 using (MemoryStream compressionMemoryStream = new MemoryStream())
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
index 7f2f5a6..4822cd5 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
@@ -737,16 +737,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
             public override int NextPosition()
             {
-                //Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
-
-                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
-                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
-                // part that is checking for an error after reading to the end of the enumerator.
-
-                // Since there is no way to turn on assertions in a release build in .NET, we are throwing an InvalidOperationException
-                // in this case, which matches the behavior of Lucene 8. See #267.
-                if (((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length) == false)
-                    throw new InvalidOperationException("Read past last position");
+                Debugging.Assert(() => (positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
 
                 if (positions != null)
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
index cd77fbc..82adf13 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
@@ -294,7 +294,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                             else
                             {
                                 Debugging.Assert(() => SameTermInfo(ti, tiOrd, enumerator));
-                                Debugging.Assert(() => enumerator.position == tiOrd.termOrd);
+                                Debugging.Assert(() => (int)enumerator.position == tiOrd.termOrd);
                             }
                         }
                     }
diff --git a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
index e8265ce..f9409ae 100644
--- a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
@@ -275,8 +275,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     WriteBits(output);
                 }
                 CodecUtil.WriteFooter(output);
-                bool verified = VerifyCount();
-                Debugging.Assert(() => verified);
+                Debugging.Assert(VerifyCount);
             }
             finally
             {
@@ -475,8 +474,7 @@ namespace Lucene.Net.Codecs.Lucene40
             Debugging.Assert(() => count != -1);
             int countSav = count;
             count = -1;
-            bool checkCount = countSav == Count();
-            Debugging.Assert(() => checkCount, () => "saved count was " + countSav + " but recomputed count is " + count);
+            Debugging.Assert(() => countSav == Count(), () => "saved count was " + countSav + " but recomputed count is " + count);
             return true;
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
index ceca2e2..8251d2e 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
@@ -730,16 +730,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             public override int NextPosition()
             {
-                //Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
-
-                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
-                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
-                // part that is checking for an error after reading to the end of the enumerator.
-
-                // Since there is no way to turn on assertions in a release build in .NET, we are throwing an InvalidOperationException
-                // in this case, which matches the behavior of Lucene 8. See #267.
-                if (((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length) == false)
-                    throw new InvalidOperationException("Read past last position");
+                Debugging.Assert(() => (positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
 
                 if (positions != null)
                 {
diff --git a/src/Lucene.Net/Index/CheckIndex.cs b/src/Lucene.Net/Index/CheckIndex.cs
index 2d58581..e2e30fd 100644
--- a/src/Lucene.Net/Index/CheckIndex.cs
+++ b/src/Lucene.Net/Index/CheckIndex.cs
@@ -1235,13 +1235,14 @@ namespace Lucene.Net.Index
                                 }
                                 lastPos = pos;
                                 BytesRef payload = postings.GetPayload();
-                                if (payload != null)
+                                // LUCENENET specific - restructured to reduce number of checks in production
+                                if (!(payload is null))
                                 {
                                     Debugging.Assert(payload.IsValid);
-                                }
-                                if (payload != null && payload.Length < 1)
-                                {
-                                    throw new Exception("term " + term + ": doc " + doc + ": pos " + pos + " payload length is out of bounds " + payload.Length);
+                                    if (payload.Length < 1)
+                                    {
+                                        throw new Exception("term " + term + ": doc " + doc + ": pos " + pos + " payload length is out of bounds " + payload.Length);
+                                    }
                                 }
                                 if (hasOffsets)
                                 {
@@ -2356,19 +2357,20 @@ namespace Lucene.Net.Index
             result.NewSegments.Commit(result.Dir);
         }
 
-        private static bool assertsOn;
+        // LUCENENET: Not used
+        //private static bool assertsOn;
 
-        private static bool TestAsserts()
-        {
-            assertsOn = true;
-            return true;
-        }
+        //private static bool TestAsserts()
+        //{
+        //    assertsOn = true;
+        //    return true;
+        //}
 
-        private static bool AssertsOn()
-        {
-            Debugging.Assert(TestAsserts);
-            return assertsOn;
-        }
+        //private static bool AssertsOn()
+        //{
+        //    Debugging.Assert(TestAsserts);
+        //    return assertsOn;
+        //}
 
         ///// Command-line interface to check and fix an index.
         /////
@@ -2473,12 +2475,14 @@ namespace Lucene.Net.Index
                 //Environment.Exit(1);
             }
 
-            // LUCENENET specific - doesn't apply
+            // LUCENENET specific - rather than having the user specify whether to enable asserts, we always run with them enabled.
+            Debugging.AssertsEnabled = true;
             //if (!AssertsOn())
             //{
             //    Console.WriteLine("\nNOTE: testing will be more thorough if you run java with '-ea:org.apache.lucene...', so assertions are enabled");
             //}
 
+
             if (onlySegments.Count == 0)
             {
                 onlySegments = null;
diff --git a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
index f394b4f..c6d0913 100644
--- a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
+++ b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
@@ -1,5 +1,6 @@
 #if FEATURE_CONCURRENTMERGESCHEDULER
 using J2N.Threading;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
@@ -394,7 +395,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(!Thread.holdsLock(writer));
+                Debugging.Assert(() => !Monitor.IsEntered(writer));
 
                 this.m_writer = writer;
 
diff --git a/src/Lucene.Net/Index/DirectoryReader.cs b/src/Lucene.Net/Index/DirectoryReader.cs
index f34c2e5..4bb5997 100644
--- a/src/Lucene.Net/Index/DirectoryReader.cs
+++ b/src/Lucene.Net/Index/DirectoryReader.cs
@@ -1,7 +1,6 @@
 using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 
 namespace Lucene.Net.Index
diff --git a/src/Lucene.Net/Index/DocFieldProcessor.cs b/src/Lucene.Net/Index/DocFieldProcessor.cs
index 2cdce5e..177b450 100644
--- a/src/Lucene.Net/Index/DocFieldProcessor.cs
+++ b/src/Lucene.Net/Index/DocFieldProcessor.cs
@@ -2,7 +2,6 @@ using J2N.Text;
 using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using JCG = J2N.Collections.Generic;
 
diff --git a/src/Lucene.Net/Index/DocTermOrds.cs b/src/Lucene.Net/Index/DocTermOrds.cs
index eaa41ca..79121c4 100644
--- a/src/Lucene.Net/Index/DocTermOrds.cs
+++ b/src/Lucene.Net/Index/DocTermOrds.cs
@@ -1,7 +1,6 @@
 using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 
 namespace Lucene.Net.Index
@@ -23,9 +22,9 @@ namespace Lucene.Net.Index
      * limitations under the License.
      */
 
-    using IBits = Lucene.Net.Util.IBits;
     using BytesRef = Lucene.Net.Util.BytesRef;
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
+    using IBits = Lucene.Net.Util.IBits;
     using PagedBytes = Lucene.Net.Util.PagedBytes;
     using PostingsFormat = Lucene.Net.Codecs.PostingsFormat; // javadocs
     using SeekStatus = Lucene.Net.Index.TermsEnum.SeekStatus;
diff --git a/src/Lucene.Net/Index/DocValuesFieldUpdates.cs b/src/Lucene.Net/Index/DocValuesFieldUpdates.cs
index b2eaf0a..983914a 100644
--- a/src/Lucene.Net/Index/DocValuesFieldUpdates.cs
+++ b/src/Lucene.Net/Index/DocValuesFieldUpdates.cs
@@ -114,14 +114,14 @@ namespace Lucene.Net.Index
                 {
                     case DocValuesFieldUpdatesType.NUMERIC:
                         NumericDocValuesFieldUpdates numericUpdates;
-                        Debugging.Assert(() => !numericDVUpdates.TryGetValue(field, out numericUpdates));
+                        Debugging.Assert(() => !numericDVUpdates.ContainsKey(field));
                         numericUpdates = new NumericDocValuesFieldUpdates(field, maxDoc);
                         numericDVUpdates[field] = numericUpdates;
                         return numericUpdates;
 
                     case DocValuesFieldUpdatesType.BINARY:
                         BinaryDocValuesFieldUpdates binaryUpdates;
-                        Debugging.Assert(() => !binaryDVUpdates.TryGetValue(field, out binaryUpdates));
+                        Debugging.Assert(() => !binaryDVUpdates.ContainsKey(field));
                         binaryUpdates = new BinaryDocValuesFieldUpdates(field, maxDoc);
                         binaryDVUpdates[field] = binaryUpdates;
                         return binaryUpdates;
diff --git a/src/Lucene.Net/Index/DocumentsWriter.cs b/src/Lucene.Net/Index/DocumentsWriter.cs
index 7264902..4707b40 100644
--- a/src/Lucene.Net/Index/DocumentsWriter.cs
+++ b/src/Lucene.Net/Index/DocumentsWriter.cs
@@ -3,10 +3,8 @@ using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading;
-using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Index
@@ -32,8 +30,8 @@ namespace Lucene.Net.Index
     using BinaryDocValuesUpdate = Lucene.Net.Index.DocValuesUpdate.BinaryDocValuesUpdate;
     using BytesRef = Lucene.Net.Util.BytesRef;
     using Directory = Lucene.Net.Store.Directory;
-    using IEvent = Lucene.Net.Index.IndexWriter.IEvent;
     using FlushedSegment = Lucene.Net.Index.DocumentsWriterPerThread.FlushedSegment;
+    using IEvent = Lucene.Net.Index.IndexWriter.IEvent;
     using InfoStream = Lucene.Net.Util.InfoStream;
     using NumericDocValuesUpdate = Lucene.Net.Index.DocValuesUpdate.NumericDocValuesUpdate;
     using Query = Lucene.Net.Search.Query;
@@ -246,7 +244,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(!Thread.HoldsLock(writer), "IndexWriter lock should never be hold when aborting");
+                Debugging.Assert(() => !Monitor.IsEntered(writer), () => "IndexWriter lock should never be hold when aborting");
                 bool success = false;
                 JCG.HashSet<string> newFilesSet = new JCG.HashSet<string>();
                 try
@@ -289,7 +287,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(indexWriter.HoldsFullFlushLock());
+                Debugging.Assert(() => indexWriter.HoldsFullFlushLock);
                 if (infoStream.IsEnabled("DW"))
                 {
                     infoStream.Message("DW", "lockAndAbortAll");
@@ -329,7 +327,7 @@ namespace Lucene.Net.Index
 
         private void AbortThreadState(ThreadState perThread, ISet<string> newFiles)
         {
-            //Debugging.Assert(perThread.HeldByCurrentThread);
+            Debugging.Assert(() => perThread.IsHeldByCurrentThread);
             if (perThread.IsActive) // we might be closed
             {
                 if (perThread.IsInitialized)
@@ -360,7 +358,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(indexWriter.HoldsFullFlushLock());
+                Debugging.Assert(() => indexWriter.HoldsFullFlushLock);
                 if (infoStream.IsEnabled("DW"))
                 {
                     infoStream.Message("DW", "unlockAll");
@@ -371,10 +369,10 @@ namespace Lucene.Net.Index
                     try
                     {
                         ThreadState perThread = perThreadPool.GetThreadState(i);
-                        //if (perThread.HeldByCurrentThread)
-                        //{
-                        perThread.Unlock();
-                        //}
+                        if (perThread.IsHeldByCurrentThread)
+                        {
+                            perThread.Unlock();
+                        }
                     }
                     catch (Exception e)
                     {
diff --git a/src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs b/src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs
index 0eee1e0..b79a7be 100644
--- a/src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs
+++ b/src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs
@@ -2,7 +2,6 @@ using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Support.Threading;
 using System;
-using System.Diagnostics;
 using System.Threading;
 
 namespace Lucene.Net.Index
diff --git a/src/Lucene.Net/Index/DocumentsWriterFlushControl.cs b/src/Lucene.Net/Index/DocumentsWriterFlushControl.cs
index 527413e..20582bb 100644
--- a/src/Lucene.Net/Index/DocumentsWriterFlushControl.cs
+++ b/src/Lucene.Net/Index/DocumentsWriterFlushControl.cs
@@ -3,7 +3,6 @@ using J2N.Threading.Atomic;
 using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using JCG = J2N.Collections.Generic;
 
@@ -153,7 +152,11 @@ namespace Lucene.Net.Index
                      * fail. To prevent this we only assert if the the largest document seen
                      * is smaller than the 1/2 of the maxRamBufferMB
                      */
-                    Debugging.Assert(() => ram <= expected, () => "actual mem: " + ram + " byte, expected mem: " + expected + " byte, flush mem: " + flushBytes + ", active mem: " + activeBytes + ", pending DWPT: " + numPending + ", flushing DWPT: " + NumFlushingDWPT + ", blocked DWPT: " + NumBlockedFlushes + ", peakDelta mem: " + peakDelta + " byte");
+                    Debugging.Assert(() => ram <= expected, () => "actual mem: " + ram + " byte, expected mem: " + expected
+                        + " byte, flush mem: " + flushBytes + ", active mem: " + activeBytes
+                        + ", pending DWPT: " + numPending + ", flushing DWPT: "
+                        + NumFlushingDWPT + ", blocked DWPT: " + NumBlockedFlushes
+                        + ", peakDelta mem: " + peakDelta + " byte");
                 }
             }
             return true;
@@ -290,7 +293,7 @@ namespace Lucene.Net.Index
 
         private bool UpdateStallState()
         {
-            //Debugging.Assert(Thread.holdsLock(this));
+            Debugging.Assert(() => Monitor.IsEntered(this));
             long limit = StallLimitBytes;
             /*
              * we block indexing threads if net byte grows due to slow flushes
diff --git a/src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs b/src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs
index 67350ce..49f535b 100644
--- a/src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs
+++ b/src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs
@@ -2,7 +2,7 @@ using J2N.Threading.Atomic;
 using Lucene.Net.Diagnostics;
 using Lucene.Net.Support.Threading;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Threading;
 
 namespace Lucene.Net.Index
 {
@@ -128,7 +128,7 @@ namespace Lucene.Net.Index
 
         private int InnerPurge(IndexWriter writer)
         {
-            //Debugging.Assert(PurgeLock.HeldByCurrentThread);
+            Debugging.Assert(() => purgeLock.IsHeldByCurrentThread);
             int numPurged = 0;
             while (true)
             {
@@ -173,8 +173,8 @@ namespace Lucene.Net.Index
 
         internal virtual int ForcePurge(IndexWriter writer)
         {
-            //Debugging.Assert(!Thread.HoldsLock(this));
-            //Debugging.Assert(!Thread.holdsLock(writer));
+            Debugging.Assert(() => !Monitor.IsEntered(this));
+            Debugging.Assert(() => !Monitor.IsEntered(writer));
             purgeLock.@Lock();
             try
             {
@@ -188,8 +188,8 @@ namespace Lucene.Net.Index
 
         internal virtual int TryPurge(IndexWriter writer)
         {
-            //Debugging.Assert(!Thread.holdsLock(this));
-            //Debugging.Assert(!Thread.holdsLock(writer));
+            Debugging.Assert(() => !Monitor.IsEntered(this));
+            Debugging.Assert(() => !Monitor.IsEntered(writer));
             if (purgeLock.TryLock())
             {
                 try
diff --git a/src/Lucene.Net/Index/DocumentsWriterPerThreadPool.cs b/src/Lucene.Net/Index/DocumentsWriterPerThreadPool.cs
index b96f063..ef4deb7 100644
--- a/src/Lucene.Net/Index/DocumentsWriterPerThreadPool.cs
+++ b/src/Lucene.Net/Index/DocumentsWriterPerThreadPool.cs
@@ -80,14 +80,14 @@ namespace Lucene.Net.Index
             /// <seealso cref="IsActive"/>
             internal void Deactivate() // LUCENENET NOTE: Made internal because it is called outside of this context
             {
-                //Debugging.Assert(this.HeldByCurrentThread);
+                Debugging.Assert(() => this.IsHeldByCurrentThread);
                 isActive = false;
                 Reset();
             }
 
             internal void Reset() // LUCENENET NOTE: Made internal because it is called outside of this context
             {
-                //Debugging.Assert(this.HeldByCurrentThread);
+                Debugging.Assert(() => this.IsHeldByCurrentThread);
                 this.dwpt = null;
                 this.bytesUsed = 0;
                 this.flushPending = false;
@@ -98,30 +98,52 @@ namespace Lucene.Net.Index
             /// only return <c>false</c> iff the DW has been disposed and this
             /// <see cref="ThreadState"/> is already checked out for flush.
             /// </summary>
-            internal bool IsActive =>
-                //Debugging.Assert(this.HeldByCurrentThread);
-                isActive;
+            internal bool IsActive
+            {
+                get
+                {
+                    Debugging.Assert(() => this.IsHeldByCurrentThread);
+                    return isActive;
+                }
+
+            }
 
-            internal bool IsInitialized =>
-                //Debugging.Assert(this.HeldByCurrentThread);
-                IsActive && dwpt != null;
+            internal bool IsInitialized
+            {
+                get
+                {
+                    Debugging.Assert(() => this.IsHeldByCurrentThread);
+                    return IsActive && dwpt != null;
+                }
+            }
+                
 
             /// <summary>
             /// Returns the number of currently active bytes in this ThreadState's
             /// <see cref="DocumentsWriterPerThread"/>
             /// </summary>
-            public long BytesUsedPerThread =>
-                //Debugging.Assert(this.HeldByCurrentThread);
-                // public for FlushPolicy
-                bytesUsed;
+            public long BytesUsedPerThread
+            {
+                get
+                {
+                    Debugging.Assert(() => this.IsHeldByCurrentThread);
+                    // public for FlushPolicy
+                    return bytesUsed;
+                }
+            }
 
             /// <summary>
             /// Returns this <see cref="ThreadState"/>s <see cref="DocumentsWriterPerThread"/>
             /// </summary>
-            public DocumentsWriterPerThread DocumentsWriterPerThread =>
-                //Debugging.Assert(this.HeldByCurrentThread);
-                // public for FlushPolicy
-                dwpt;
+            public DocumentsWriterPerThread DocumentsWriterPerThread
+            {
+                get
+                {
+                    Debugging.Assert(() => this.IsHeldByCurrentThread);
+                    // public for FlushPolicy
+                    return dwpt;
+                }
+            }
 
             /// <summary>
             /// Returns <c>true</c> iff this <see cref="ThreadState"/> is marked as flush
@@ -270,7 +292,7 @@ namespace Lucene.Net.Index
 
         internal virtual DocumentsWriterPerThread Reset(ThreadState threadState, bool closed)
         {
-            //Debugging.Assert(threadState.HeldByCurrentThread);
+            Debugging.Assert(() => threadState.IsHeldByCurrentThread);
             DocumentsWriterPerThread dwpt = threadState.dwpt;
             if (!closed)
             {
diff --git a/src/Lucene.Net/Index/DocumentsWriterStallControl.cs b/src/Lucene.Net/Index/DocumentsWriterStallControl.cs
index 11c1f1b..ab3bb0d 100644
--- a/src/Lucene.Net/Index/DocumentsWriterStallControl.cs
+++ b/src/Lucene.Net/Index/DocumentsWriterStallControl.cs
@@ -85,13 +85,13 @@ namespace Lucene.Net.Index
 //                        try
 //                        {
 //#endif
-                        // make sure not to run IncWaiters / DecrWaiters in Debug.Assert as that gets 
-                        // removed at compile time if built in Release mode
+                        // LUCENENET: make sure not to run IncWaiters / DecrWaiters in Debugging.Assert as that gets 
+                        // disabled in production
                         var result = IncWaiters();
-                            Debugging.Assert(() => result);
-                            Monitor.Wait(this);
-                            result = DecrWaiters();
-                            Debugging.Assert(() => result);
+                        Debugging.Assert(() => result);
+                        Monitor.Wait(this);
+                        result = DecrWaiters();
+                        Debugging.Assert(() => result);
 //#if !NETSTANDARD1_6 // LUCENENET NOTE: Senseless to catch and rethrow the same exception type
 //                        }
 //                        catch (ThreadInterruptedException e)
@@ -112,8 +112,7 @@ namespace Lucene.Net.Index
         private bool IncWaiters()
         {
             numWaiting++;
-            bool existed = waiting.ContainsKey(ThreadJob.CurrentThread);
-            Debugging.Assert(() => !existed);
+            Debugging.Assert(() => !waiting.ContainsKey(ThreadJob.CurrentThread));
             waiting[ThreadJob.CurrentThread] = true;
 
             return numWaiting > 0;
diff --git a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
index 8e961a7..e5757ea 100644
--- a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
+++ b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
@@ -197,8 +197,7 @@ namespace Lucene.Net.Index
         {
             // First time we're seeing this term since the last
             // flush
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docState.TestPoint("FreqProxTermsWriterPerField.newTerm start");
+            Debugging.Assert(() => docState.TestPoint("FreqProxTermsWriterPerField.newTerm start"));
 
             FreqProxPostingsArray postings = (FreqProxPostingsArray)termsHashPerField.postingsArray;
             postings.lastDocIDs[termID] = docState.docID;
diff --git a/src/Lucene.Net/Index/IndexFileDeleter.cs b/src/Lucene.Net/Index/IndexFileDeleter.cs
index 6b38589..df29f18 100644
--- a/src/Lucene.Net/Index/IndexFileDeleter.cs
+++ b/src/Lucene.Net/Index/IndexFileDeleter.cs
@@ -532,7 +532,7 @@ namespace Lucene.Net.Index
         {
             Debugging.Assert(() => IsLocked);
 
-            //Debugging.Assert(Thread.holdsLock(Writer));
+            Debugging.Assert(() => Monitor.IsEntered(writer));
             long t0 = 0;
             if (infoStream.IsEnabled("IFD"))
             {
@@ -650,7 +650,7 @@ namespace Lucene.Net.Index
         {
             Debugging.Assert(() => IsLocked);
             // LUCENENET: Using TryGetValue to eliminate extra lookup
-            return refCounts.TryGetValue(fileName, out RefCount value) ? value.count > 0 : false;
+            return refCounts.TryGetValue(fileName, out RefCount value) && value.count > 0;
         }
 
         private RefCount GetRefCount(string fileName)
@@ -724,7 +724,7 @@ namespace Lucene.Net.Index
                 // the file is open in another process, and queue
                 // the file for subsequent deletion.
 
-                //Debugging.Assert(e.Message.Contains("cannot delete"));
+                //Debugging.Assert(() => e.Message.Contains("cannot delete"));
 
                 if (infoStream.IsEnabled("IFD"))
                 {
diff --git a/src/Lucene.Net/Index/IndexWriter.cs b/src/Lucene.Net/Index/IndexWriter.cs
index 0c23c0c..8d3d47f 100644
--- a/src/Lucene.Net/Index/IndexWriter.cs
+++ b/src/Lucene.Net/Index/IndexWriter.cs
@@ -6,7 +6,6 @@ using Lucene.Net.Support;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Runtime.CompilerServices;
@@ -708,7 +707,7 @@ namespace Lucene.Net.Index
                     }
                     else
                     {
-                        Debugging.Assert(() => rld.Info == info, () => "Infos are not equal");//, "rld.info=" + rld.Info + " info=" + info + " isLive?=" + InfoIsLive(rld.Info) + " vs " + InfoIsLive(info));
+                        Debugging.Assert(() => rld.Info == info, () => "rld.info=" + rld.Info + " info=" + info + " isLive?=" + InfoIsLive(rld.Info) + " vs " + InfoIsLive(info));
                     }
 
                     if (create)
@@ -2570,8 +2569,7 @@ namespace Lucene.Net.Index
                         infoStream.Message("IW", "rollback: infos=" + SegString(segmentInfos.Segments));
                     }
 
-                    // LUCENENET: .NET doesn't support asserts in release mode
-                    if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) TestPoint("rollback before checkpoint");
+                    Debugging.Assert(() => TestPoint("rollback before checkpoint"));
 
                     // Ask deleter to locate unreferenced files & remove
                     // them:
@@ -3816,12 +3814,8 @@ namespace Lucene.Net.Index
         /// </summary>
         private readonly object fullFlushLock = new object();
 
-        // LUCENENET NOTE: Not possible in .NET
-        //// for assert
-        //internal virtual bool HoldsFullFlushLock()
-        //{
-        //  return Thread.holdsLock(FullFlushLock);
-        //}
+        // for assert
+        internal virtual bool HoldsFullFlushLock => Monitor.IsEntered(fullFlushLock);
 
         /// <summary>
         /// Flush all in-memory buffered updates (adds and deletes)
@@ -3978,16 +3972,7 @@ namespace Lucene.Net.Index
 
         // for testing only
         internal virtual DocumentsWriter DocsWriter
-        {
-            get
-            {
-                bool test = false;
-                // LUCENENET NOTE: Must set test outside of Debug.Assert!!
-                bool isTest = test = true;
-                Debugging.Assert(() => isTest);
-                return test ? docWriter : null;
-            }
-        }
+            => Debugging.AssertsEnabled ? docWriter : null; // LUCENENET specific - just read the status, simpler than using Assert() to set a local variable
 
         /// <summary>
         /// Expert:  Return the number of documents currently
@@ -4098,8 +4083,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                // LUCENENET: .NET doesn't support asserts in release mode
-                if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) TestPoint("startCommitMergeDeletes");
+                Debugging.Assert(() => TestPoint("startCommitMergeDeletes"));
 
                 IList<SegmentCommitInfo> sourceSegments = merge.Segments;
 
@@ -4335,8 +4319,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                // LUCENENET: .NET doesn't support asserts in release mode
-                if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) TestPoint("startCommitMerge");
+                Debugging.Assert(() => TestPoint("startCommitMerge"));
 
                 if (hitOOM)
                 {
@@ -5511,8 +5494,7 @@ namespace Lucene.Net.Index
                         infoStream.Message("IW", "done all syncs: " + string.Format(J2N.Text.StringFormatter.InvariantCulture, "{0}", filesToSync));
                     }
 
-                    // LUCENENET: .NET doesn't support asserts in release mode
-                    if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) TestPoint("midStartCommitSuccess");
+                    Debugging.Assert(() => TestPoint("midStartCommitSuccess"));
                 }
                 finally
                 {
@@ -5542,8 +5524,7 @@ namespace Lucene.Net.Index
             {
                 HandleOOM(oom, "startCommit");
             }
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) TestPoint("finishStartCommit");
+            Debugging.Assert(() => TestPoint("finishStartCommit"));
         }
 
         /// <summary>
diff --git a/src/Lucene.Net/Index/PrefixCodedTerms.cs b/src/Lucene.Net/Index/PrefixCodedTerms.cs
index b914b5f..a0f03b9 100644
--- a/src/Lucene.Net/Index/PrefixCodedTerms.cs
+++ b/src/Lucene.Net/Index/PrefixCodedTerms.cs
@@ -92,6 +92,9 @@ namespace Lucene.Net.Index
 
             public virtual bool MoveNext()
             {
+                // LUCENENET specific - Since there is no way to check for a next element
+                // without calling this method in .NET, the assert is redundant and ineffective.
+                //Debugging.Assert(() => input.GetFilePointer() < input.Length); // Has next
                 if (input.GetFilePointer() < input.Length)
                 {
                     try
diff --git a/src/Lucene.Net/Index/ReadersAndUpdates.cs b/src/Lucene.Net/Index/ReadersAndUpdates.cs
index 976d412..7f8b360 100644
--- a/src/Lucene.Net/Index/ReadersAndUpdates.cs
+++ b/src/Lucene.Net/Index/ReadersAndUpdates.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
 
 namespace Lucene.Net.Index
 {
@@ -230,7 +231,7 @@ namespace Lucene.Net.Index
             lock (this)
             {
                 Debugging.Assert(() => liveDocs != null);
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 Debugging.Assert(() => docID >= 0 && docID < liveDocs.Length, () => "out of bounds: docid=" + docID + " liveDocsLength=" + liveDocs.Length + " seg=" + Info.Info.Name + " docCount=" + Info.Info.DocCount);
                 Debugging.Assert(() => !liveDocsShared);
                 bool didDelete = liveDocs.Get(docID);
@@ -318,7 +319,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 Debugging.Assert(() => Info.Info.DocCount > 0);
                 //System.out.println("initWritableLivedocs seg=" + info + " liveDocs=" + liveDocs + " shared=" + shared);
                 if (liveDocsShared)
@@ -348,7 +349,7 @@ namespace Lucene.Net.Index
             {
                 lock (this)
                 {
-                    //Debugging.Assert(Thread.holdsLock(Writer));
+                    Debugging.Assert(() => Monitor.IsEntered(writer));
                     return liveDocs;
                 }
             }
@@ -359,7 +360,7 @@ namespace Lucene.Net.Index
             lock (this)
             {
                 //System.out.println("getROLiveDocs seg=" + info);
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 liveDocsShared = true;
                 //if (liveDocs != null) {
                 //System.out.println("  liveCount=" + liveDocs.count());
@@ -393,7 +394,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 //System.out.println("rld.writeLiveDocs seg=" + info + " pendingDelCount=" + pendingDeleteCount + " numericUpdates=" + numericUpdates);
                 if (pendingDeleteCount == 0)
                 {
@@ -458,7 +459,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 //System.out.println("rld.writeFieldUpdates: seg=" + info + " numericFieldUpdates=" + numericFieldUpdates);
 
                 Debugging.Assert(dvUpdates.Any);
@@ -692,6 +693,7 @@ namespace Lucene.Net.Index
                 }
                 else
                 {   // no update for this document
+                    Debugging.Assert(() => curDoc < updateDoc);
                     if (currentValues != null && DocsWithField.Get(curDoc))
                     {
                         // only read the current value if the document had a value before
@@ -724,6 +726,7 @@ namespace Lucene.Net.Index
                 }
                 else
                 {   // no update for this document
+                    Debugging.Assert(() => curDoc < updateDoc);
                     if (currentValues != null && DocsWithField.Get(curDoc))
                     {
                         // only read the current value if the document had a value before
@@ -746,7 +749,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debugging.Assert(Thread.holdsLock(Writer));
+                Debugging.Assert(() => Monitor.IsEntered(writer));
                 // must execute these two statements as atomic operation, otherwise we
                 // could lose updates if e.g. another thread calls writeFieldUpdates in
                 // between, or the updates are applied to the obtained reader, but then
diff --git a/src/Lucene.Net/Index/SortedDocValuesWriter.cs b/src/Lucene.Net/Index/SortedDocValuesWriter.cs
index 17072c5..08c7985 100644
--- a/src/Lucene.Net/Index/SortedDocValuesWriter.cs
+++ b/src/Lucene.Net/Index/SortedDocValuesWriter.cs
@@ -148,6 +148,7 @@ namespace Lucene.Net.Index
         private IEnumerable<long?> GetOrdsEnumberable(int maxDoc, int[] ordMap)
         {
             AppendingDeltaPackedInt64Buffer.Iterator iter = pending.GetIterator();
+            Debugging.Assert(() => pending.Count == maxDoc);
 
             for (int i = 0; i < maxDoc; ++i)
             {
diff --git a/src/Lucene.Net/Index/SortedSetDocValuesWriter.cs b/src/Lucene.Net/Index/SortedSetDocValuesWriter.cs
index a85d348..3a4460a 100644
--- a/src/Lucene.Net/Index/SortedSetDocValuesWriter.cs
+++ b/src/Lucene.Net/Index/SortedSetDocValuesWriter.cs
@@ -203,7 +203,7 @@ namespace Lucene.Net.Index
         {
             AppendingDeltaPackedInt64Buffer.Iterator iter = pendingCounts.GetIterator();
 
-            Debugging.Assert(() => maxDoc == pendingCounts.Count, () => "MaxDoc: " + maxDoc + ", pending.Count: " + pending.Count);
+            Debugging.Assert(() => pendingCounts.Count == maxDoc, () => "MaxDoc: " + maxDoc + ", pending.Count: " + pending.Count);
 
             for (int i = 0; i < maxDoc; ++i)
             {
diff --git a/src/Lucene.Net/Index/StoredFieldsProcessor.cs b/src/Lucene.Net/Index/StoredFieldsProcessor.cs
index aac5b12..fb75321 100644
--- a/src/Lucene.Net/Index/StoredFieldsProcessor.cs
+++ b/src/Lucene.Net/Index/StoredFieldsProcessor.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
 namespace Lucene.Net.Index
@@ -139,8 +139,7 @@ namespace Lucene.Net.Index
         [MethodImpl(MethodImplOptions.NoInlining)]
         internal override void FinishDocument()
         {
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docWriter.TestPoint("StoredFieldsWriter.finishDocument start");
+            Debugging.Assert(() => docWriter.TestPoint("StoredFieldsWriter.finishDocument start"));
 
             InitFieldsWriter(IOContext.DEFAULT);
             Fill(docState.docID);
@@ -157,8 +156,7 @@ namespace Lucene.Net.Index
             }
 
             Reset();
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docWriter.TestPoint("StoredFieldsWriter.finishDocument end");
+            Debugging.Assert(() => docWriter.TestPoint("StoredFieldsWriter.finishDocument end"));
         }
 
         public override void AddField(int docID, IIndexableField field, FieldInfo fieldInfo)
@@ -181,8 +179,7 @@ namespace Lucene.Net.Index
                 fieldInfos[numStoredFields] = fieldInfo;
                 numStoredFields++;
 
-                // LUCENENET: .NET doesn't support asserts in release mode
-                if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docState.TestPoint("StoredFieldsWriterPerThread.processFields.writeField");
+                Debugging.Assert(() => docState.TestPoint("StoredFieldsWriterPerThread.processFields.writeField"));
             }
         }
     }
diff --git a/src/Lucene.Net/Index/TermVectorsConsumer.cs b/src/Lucene.Net/Index/TermVectorsConsumer.cs
index 94c48e7..30fb1da 100644
--- a/src/Lucene.Net/Index/TermVectorsConsumer.cs
+++ b/src/Lucene.Net/Index/TermVectorsConsumer.cs
@@ -114,8 +114,7 @@ namespace Lucene.Net.Index
         [MethodImpl(MethodImplOptions.NoInlining)]
         internal override void FinishDocument(TermsHash termsHash)
         {
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docWriter.TestPoint("TermVectorsTermsWriter.finishDocument start");
+            Debugging.Assert(() => docWriter.TestPoint("TermVectorsTermsWriter.finishDocument start"));
 
             if (!hasVectors)
             {
diff --git a/src/Lucene.Net/Index/TermVectorsConsumerPerField.cs b/src/Lucene.Net/Index/TermVectorsConsumerPerField.cs
index f8de489..032bb04 100644
--- a/src/Lucene.Net/Index/TermVectorsConsumerPerField.cs
+++ b/src/Lucene.Net/Index/TermVectorsConsumerPerField.cs
@@ -293,8 +293,7 @@ namespace Lucene.Net.Index
 
         internal override void NewTerm(int termID)
         {
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docState.TestPoint("TermVectorsTermsWriterPerField.newTerm start");
+            Debugging.Assert(() => docState.TestPoint("TermVectorsTermsWriterPerField.newTerm start"));
             TermVectorsPostingsArray postings = (TermVectorsPostingsArray)termsHashPerField.postingsArray;
 
             postings.freqs[termID] = 1;
@@ -306,8 +305,7 @@ namespace Lucene.Net.Index
 
         internal override void AddTerm(int termID)
         {
-            // LUCENENET: .NET doesn't support asserts in release mode
-            if (Lucene.Net.Diagnostics.Debugging.AssertsEnabled) docState.TestPoint("TermVectorsTermsWriterPerField.addTerm start");
+            Debugging.Assert(() => docState.TestPoint("TermVectorsTermsWriterPerField.addTerm start"));
             TermVectorsPostingsArray postings = (TermVectorsPostingsArray)termsHashPerField.postingsArray;
 
             postings.freqs[termID]++;
diff --git a/src/Lucene.Net/Index/ThreadAffinityDocumentsWriterThreadPool.cs b/src/Lucene.Net/Index/ThreadAffinityDocumentsWriterThreadPool.cs
index 3327ee9..5b46c72 100644
--- a/src/Lucene.Net/Index/ThreadAffinityDocumentsWriterThreadPool.cs
+++ b/src/Lucene.Net/Index/ThreadAffinityDocumentsWriterThreadPool.cs
@@ -50,9 +50,7 @@ namespace Lucene.Net.Index
 
         public override ThreadState GetAndLock(Thread requestingThread, DocumentsWriter documentsWriter)
         {
-            ThreadState threadState;
-            threadBindings.TryGetValue(requestingThread, out threadState);
-            if (threadState != null && threadState.TryLock())
+            if (threadBindings.TryGetValue(requestingThread, out ThreadState threadState) && threadState.TryLock())
             {
                 return threadState;
             }
@@ -67,7 +65,7 @@ namespace Lucene.Net.Index
                 ThreadState newState = NewThreadState(); // state is already locked if non-null
                 if (newState != null)
                 {
-                    //Debugging.Assert(newState.HeldByCurrentThread);
+                    Debugging.Assert(() => newState.IsHeldByCurrentThread);
                     threadBindings[requestingThread] = newState;
                     return newState;
                 }
diff --git a/src/Lucene.Net/Search/FieldCacheRangeFilter.cs b/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
index 13438e0..de70b6f 100644
--- a/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
+++ b/src/Lucene.Net/Search/FieldCacheRangeFilter.cs
@@ -230,7 +230,8 @@ namespace Lucene.Net.Search
                     return null; ;
                 }
 
-                //assert inclusiveLowerPoint >= 0 && inclusiveUpperPoint >= 0;
+                Debugging.Assert(() => inclusiveLowerPoint >= 0 && inclusiveUpperPoint >= 0);
+
                 return new AnonymousClassFieldCacheDocIdSet(fcsi, inclusiveLowerPoint, inclusiveUpperPoint, context.AtomicReader.MaxDoc, acceptDocs);
             }
         }
diff --git a/src/Lucene.Net/Search/FieldComparator.cs b/src/Lucene.Net/Search/FieldComparator.cs
index ae30170..9555bee 100644
--- a/src/Lucene.Net/Search/FieldComparator.cs
+++ b/src/Lucene.Net/Search/FieldComparator.cs
@@ -981,7 +981,7 @@ namespace Lucene.Net.Search
 
                 // LUCENENET specific special case:
                 // In case of zero, we may have a "positive 0" or "negative 0"
-                // to tie-break. So, we use JCG.Comparer<double> to do the comparison.
+                // to tie-break. So, we use JCG.Comparer<float> to do the comparison.
                 return JCG.Comparer<float>.Default.Compare(second, first);
             }
 
@@ -992,7 +992,7 @@ namespace Lucene.Net.Search
 
                 // LUCENENET specific special case:
                 // In case of zero, we may have a "positive 0" or "negative 0"
-                // to tie-break. So, we use JCG.Comparer<double> to do the comparison.
+                // to tie-break. So, we use JCG.Comparer<float> to do the comparison.
                 return JCG.Comparer<float>.Default.Compare(docValue, topValue);
             }
         }
diff --git a/src/Lucene.Net/Search/ReferenceManager.cs b/src/Lucene.Net/Search/ReferenceManager.cs
index 06f6292..d9ab9c8 100644
--- a/src/Lucene.Net/Search/ReferenceManager.cs
+++ b/src/Lucene.Net/Search/ReferenceManager.cs
@@ -200,7 +200,7 @@ namespace Lucene.Net.Search
                     G newReference = RefreshIfNeeded(reference);
                     if (newReference != null)
                     {
-                        Debugging.Assert(() => (object)newReference != (object)reference, () => "refreshIfNeeded should return null if refresh wasn't needed");
+                        Debugging.Assert(() => !ReferenceEquals(newReference, reference), () => "refreshIfNeeded should return null if refresh wasn't needed");
                         try
                         {
                             SwapReference(newReference);
@@ -311,7 +311,7 @@ namespace Lucene.Net.Search
         /// <exception cref="IOException"> If the release operation on the given resource throws an <see cref="IOException"/> </exception>
         public void Release(G reference)
         {
-            Debugging.Assert(() => reference != null);
+            Debugging.Assert(() => !(reference is null));
             DecRef(reference);
         }
 
diff --git a/src/Lucene.Net/Store/ByteBufferIndexInput.cs b/src/Lucene.Net/Store/ByteBufferIndexInput.cs
index 821ce70..8402ad9 100644
--- a/src/Lucene.Net/Store/ByteBufferIndexInput.cs
+++ b/src/Lucene.Net/Store/ByteBufferIndexInput.cs
@@ -1,5 +1,6 @@
 using J2N.IO;
 using Lucene.Net.Diagnostics;
+using Lucene.Net.Util.Fst;
 using System;
 using System.IO;
 using System.Runtime.CompilerServices;
@@ -390,6 +391,7 @@ namespace Lucene.Net.Store
 #if FEATURE_CONDITIONALWEAKTABLE_ENUMERATOR
                         foreach (var pair in clones)
                         {
+                            Debugging.Assert(() => pair.Key.isClone);
                             pair.Key.UnsetBuffers();
                         }
                         this.clones.Clear();
diff --git a/src/Lucene.Net/Store/NIOFSDirectory.cs b/src/Lucene.Net/Store/NIOFSDirectory.cs
index bf26d21..8eefa14 100644
--- a/src/Lucene.Net/Store/NIOFSDirectory.cs
+++ b/src/Lucene.Net/Store/NIOFSDirectory.cs
@@ -257,16 +257,9 @@ namespace Lucene.Net.Store
                 {
                     while (readLength > 0)
                     {
-                        int limit;
-                        if (readLength > CHUNK_SIZE)
-                        {
-                            limit = readOffset + CHUNK_SIZE;
-                        }
-                        else
-                        {
-                            limit = readOffset + readLength;
-                        }
-                        bb.Limit = limit;
+                        int toRead = Math.Min(CHUNK_SIZE, readLength);
+                        bb.Limit = readOffset + toRead;
+                        Debugging.Assert(() => bb.Remaining == toRead);
                         int i = m_channel.Read(bb, pos);
                         if (i <= 0) // be defensive here, even though we checked before hand, something could have changed
                         {
diff --git a/src/Lucene.Net/Store/SimpleFSDirectory.cs b/src/Lucene.Net/Store/SimpleFSDirectory.cs
index 8006f06..35167d9 100644
--- a/src/Lucene.Net/Store/SimpleFSDirectory.cs
+++ b/src/Lucene.Net/Store/SimpleFSDirectory.cs
@@ -1,5 +1,5 @@
+using Lucene.Net.Diagnostics;
 using System;
-using System.Diagnostics;
 using System.IO;
 
 namespace Lucene.Net.Store
@@ -235,7 +235,7 @@ namespace Lucene.Net.Store
                         // all we need to do is Read().
                         total = m_file.Read(b, offset, len);
 
-                        //Debugging.Assert(total == len);
+                        Debugging.Assert(() => total == len);
                     }
                     catch (IOException ioe)
                     {
diff --git a/src/Lucene.Net/Util/BroadWord.cs b/src/Lucene.Net/Util/BroadWord.cs
index c70029c..db7241c 100644
--- a/src/Lucene.Net/Util/BroadWord.cs
+++ b/src/Lucene.Net/Util/BroadWord.cs
@@ -1,5 +1,6 @@
 using J2N.Numerics;
 using Lucene.Net.Diagnostics;
+using System.Globalization;
 
 namespace Lucene.Net.Util
 {
@@ -70,7 +71,7 @@ namespace Lucene.Net.Util
             long b = (long)((ulong)(((long)((ulong)SmallerUpTo7_8(s, (r * L8_L)) >> 7)) * L8_L) >> 53); // & (~7L); // Step 3, side ways addition for byte number times 8
 
             long l = r - (((long)((ulong)(s << 8) >> (int)b)) & 0xFFL); // Step 4, byte wise rank, subtract the rank with byte at b-8, or zero for b=0;
-            Debugging.Assert(() => 0L <= 1);
+            Debugging.Assert(() => 0L <= 1, () => l.ToString(CultureInfo.InvariantCulture));
             //assert l < 8 : l; //fails when bit r is not available.
 
             // Select bit l from byte (x >>> b):
diff --git a/src/Lucene.Net/Util/Fst/FST.cs b/src/Lucene.Net/Util/Fst/FST.cs
index 2eec5f7..86bd528 100644
--- a/src/Lucene.Net/Util/Fst/FST.cs
+++ b/src/Lucene.Net/Util/Fst/FST.cs
@@ -376,8 +376,7 @@ namespace Lucene.Net.Util.Fst
             cachedRootArcs = (FST.Arc<T>[])new FST.Arc<T>[0x80];
             ReadRootArcs(cachedRootArcs);
 
-            bool set = SetAssertingRootArcs(cachedRootArcs);
-            Debugging.Assert(() => set);
+            Debugging.Assert(() => SetAssertingRootArcs(cachedRootArcs));
             Debugging.Assert(AssertRootArcs);
         }
 
@@ -409,7 +408,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        private bool SetAssertingRootArcs(FST.Arc<T>[] arcs)
+        private bool SetAssertingRootArcs(FST.Arc<T>[] arcs) // Only called from assert
         {
             assertingCachedRootArcs = (FST.Arc<T>[])new FST.Arc<T>[arcs.Length];
             ReadRootArcs(assertingCachedRootArcs);
diff --git a/src/Lucene.Net/Util/Fst/NodeHash.cs b/src/Lucene.Net/Util/Fst/NodeHash.cs
index ad402d0..8e6460f 100644
--- a/src/Lucene.Net/Util/Fst/NodeHash.cs
+++ b/src/Lucene.Net/Util/Fst/NodeHash.cs
@@ -162,8 +162,7 @@ namespace Lucene.Net.Util.Fst
                     // freeze & add
                     long node = fst.AddNode(nodeIn);
                     //System.out.println("  now freeze node=" + node);
-                    long hashNode = Hash(node);
-                    Debugging.Assert(() => hashNode == h, () => "frozenHash=" + hashNode + " vs h=" + h);
+                    Debugging.Assert(() => Hash(node) == h, () => "frozenHash=" + Hash(node) + " vs h=" + h);
                     count++;
                     table.Set(pos, node);
                     // Rehash at 2/3 occupancy:
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
index 1fb241c..470b76e 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
@@ -3,6 +3,7 @@ using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.Text;
 
 namespace Lucene.Net.Util.Packed
@@ -219,7 +220,7 @@ namespace Lucene.Net.Util.Packed
         /// </summary>
         private static long NumInt64sForBits(long numBits) // Note: int version in FixedBitSet.bits2words()
         {
-            Debugging.Assert(() => numBits >= 0, numBits.ToString);
+            Debugging.Assert(() => numBits >= 0, () => numBits.ToString(CultureInfo.InvariantCulture));
             return (long)((ulong)(numBits + (sizeof(long) * 8 - 1)) >> LOG2_INT64_SIZE);
         }
 
diff --git a/src/Lucene.Net/Util/Packed/PackedDataInput.cs b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
index bf09213..89e266a 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataInput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Diagnostics;
 using System;
+using System.Globalization;
 
 namespace Lucene.Net.Util.Packed
 {
@@ -52,7 +53,7 @@ namespace Lucene.Net.Util.Packed
         /// </summary>
         public long ReadInt64(int bitsPerValue)
         {
-            Debugging.Assert(() => bitsPerValue > 0 && bitsPerValue <= 64, bitsPerValue.ToString);
+            Debugging.Assert(() => bitsPerValue > 0 && bitsPerValue <= 64, () => bitsPerValue.ToString(CultureInfo.InvariantCulture));
             long r = 0;
             while (bitsPerValue > 0)
             {
diff --git a/src/Lucene.Net/Util/Packed/PackedInts.cs b/src/Lucene.Net/Util/Packed/PackedInts.cs
index c9da5f8..fac1a53 100644
--- a/src/Lucene.Net/Util/Packed/PackedInts.cs
+++ b/src/Lucene.Net/Util/Packed/PackedInts.cs
@@ -3,6 +3,7 @@ using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 
 namespace Lucene.Net.Util.Packed
@@ -141,8 +142,8 @@ namespace Lucene.Net.Util.Packed
             /// </summary>
             public override float OverheadPerValue(int bitsPerValue)
             {
+                Debugging.Assert(() => IsSupported(bitsPerValue));
                 int valuesPerBlock = 64 / bitsPerValue;
-
                 int overhead = 64 % bitsPerValue;
                 return (float)overhead / valuesPerBlock;
             }
@@ -204,6 +205,7 @@ namespace Lucene.Net.Util.Packed
             /// </summary>
             public virtual long ByteCount(int packedIntsVersion, int valueCount, int bitsPerValue)
             {
+                Debugging.Assert(() => bitsPerValue >= 0 && bitsPerValue <= 64, () => bitsPerValue.ToString(CultureInfo.InvariantCulture));
                 // assume long-aligned
                 return 8L * Int64Count(packedIntsVersion, valueCount, bitsPerValue);
             }
@@ -216,16 +218,13 @@ namespace Lucene.Net.Util.Packed
             /// </summary>
             public virtual int Int64Count(int packedIntsVersion, int valueCount, int bitsPerValue)
             {
+                Debugging.Assert(() => bitsPerValue >= 0 && bitsPerValue <= 64, () => bitsPerValue.ToString(CultureInfo.InvariantCulture));
                 long byteCount = ByteCount(packedIntsVersion, valueCount, bitsPerValue);
-
+                Debugging.Assert(() => byteCount < 8L * int.MaxValue);
                 if ((byteCount % 8) == 0)
-                {
                     return (int)(byteCount / 8);
-                }
                 else
-                {
                     return (int)(byteCount / 8 + 1);
-                }
             }
 
             /// <summary>
diff --git a/src/Lucene.Net/Util/Packed/PackedWriter.cs b/src/Lucene.Net/Util/Packed/PackedWriter.cs
index aaea243..2df619f 100644
--- a/src/Lucene.Net/Util/Packed/PackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/PackedWriter.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
+using System.Globalization;
 using System.IO;
 using System.Runtime.CompilerServices;
 
@@ -55,7 +56,7 @@ namespace Lucene.Net.Util.Packed
 
         public override void Add(long v)
         {
-            Debugging.Assert(() => m_bitsPerValue == 64 || (v >= 0 && v <= PackedInt32s.MaxValue(m_bitsPerValue)), m_bitsPerValue.ToString);
+            Debugging.Assert(() => m_bitsPerValue == 64 || (v >= 0 && v <= PackedInt32s.MaxValue(m_bitsPerValue)), () => m_bitsPerValue.ToString(CultureInfo.InvariantCulture));
             Debugging.Assert(() => !finished);
             if (m_valueCount != -1 && written >= m_valueCount)
             {
diff --git a/src/Lucene.Net/Util/PagedBytes.cs b/src/Lucene.Net/Util/PagedBytes.cs
index e80ab68..dd392cb 100644
--- a/src/Lucene.Net/Util/PagedBytes.cs
+++ b/src/Lucene.Net/Util/PagedBytes.cs
@@ -2,6 +2,7 @@ using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 
 namespace Lucene.Net.Util
 {
@@ -162,7 +163,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public PagedBytes(int blockBits)
         {
-            Debugging.Assert(() => blockBits > 0 && blockBits <= 31, blockBits.ToString);
+            Debugging.Assert(() => blockBits > 0 && blockBits <= 31, () => blockBits.ToString(CultureInfo.InvariantCulture));
             this.blockSize = 1 << blockBits;
             this.blockBits = blockBits;
             blockMask = blockSize - 1;
diff --git a/src/Lucene.Net/Util/RamUsageEstimator.cs b/src/Lucene.Net/Util/RamUsageEstimator.cs
index 493104b..298009b 100644
--- a/src/Lucene.Net/Util/RamUsageEstimator.cs
+++ b/src/Lucene.Net/Util/RamUsageEstimator.cs
@@ -507,7 +507,7 @@ namespace Lucene.Net.Util
                 seen.Add(ob);
 
                 Type obClazz = ob.GetType();
-
+                // LUCENENET specific - .NET cannot return a null type for an object, so no need to assert it
                 if (obClazz.Equals(typeof(string)))
                 {
                     // LUCENENET specific - we can get a closer estimate of a string
diff --git a/src/Lucene.Net/Util/RollingBuffer.cs b/src/Lucene.Net/Util/RollingBuffer.cs
index c6479ca..7558150 100644
--- a/src/Lucene.Net/Util/RollingBuffer.cs
+++ b/src/Lucene.Net/Util/RollingBuffer.cs
@@ -140,6 +140,8 @@ namespace Lucene.Net.Util
             }
             Debugging.Assert(() => InBounds(pos));
             int index = GetIndex(pos);
+            //System.out.println("  pos=" + pos + " nextPos=" + nextPos + " -> index=" + index);
+            //assert buffer[index].pos == pos;
             return buffer[index];
         }
 


[lucenenet] 13/13: azure-pipelines.yml: Added option to disable asserts when running tests

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit e8bc15f60a7280cbe44503eea133dadb85affb17
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Tue Aug 25 00:53:21 2020 +0700

    azure-pipelines.yml: Added option to disable asserts when running tests
---
 azure-pipelines.yml | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 2632b46..2c00b49 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -36,6 +36,7 @@ name: 'vNext$(rev:.r)' # Format for build number (will be overridden)
 # Testing variables
 
 # RunTests: 'true' (Optional - set to 'false' to disable test jobs - useful for debugging. If not provided, tests will be run.)
+# AssertsEnabled: 'true' (Optional - set to 'false' to run tests without asserts, which is less thorough. This can speed up testing and verify the application will run without asserts.)
 # IsNightly: 'false' (Optional - set to 'true' to run additional tests for the nightly build)
 # IsWeekly: 'false' (Optional - set to 'true' to run additional tests for the weekly build)
 # RunSlowTests: 'true' (Optional - set to 'false' to skip slow tests to make testing time shorter)
@@ -143,6 +144,7 @@ stages:
 
     - pwsh: |
         # Generate a lucene.testsettings.json file for use with the test framework
+        $assert = if ($Env:AssertsEnabled -ne 'false') { 'true' } else { 'false' }
         $nightly = if ($Env:IsNightly -eq 'true') { 'true' } else { 'false' }
         $weekly = if ($Env:IsWeekly -eq 'true') { 'true' } else { 'false' }
         $slow = if ($Env:RunSlowTests -ne 'false') { 'true' } else { 'false' }
@@ -153,18 +155,21 @@ stages:
         $directory = if ($Env:Directory -eq $null) { 'random' } else { $Env:Directory }
         $verbose = if ($Env:Verbose -eq 'true') { 'true' } else { 'false' }
         $multiplier = if ($Env:Multiplier -eq $null) { '1' } else { $Env:Multiplier }
-        $fileText = "{`n`t""tests"":`n`t{`n`t`t" +
-                        """nightly"": ""$nightly"",`n`t`t" +
-                        """weekly"": ""$weekly"",`n`t`t" +
-                        """slow"": ""$slow"",`n`t`t" +
-                        """awaitsfix"": ""$awaitsFix"",`n`t`t" +
-                        """codec"": ""$codec"",`n`t`t" +
-                        """docvaluesformat"": ""$docValuesFormat"",`n`t`t" +
-                        """postingsformat"": ""$postingsFormat"",`n`t`t" +
-                        """directory"": ""$directory"",`n`t`t" +
-                        """verbose"": ""$verbose"",`n`t`t" +
-                        """multiplier"": ""$multiplier""`n`t" +
-                    "}`n}"
+        $fileText = "{`n`t" +
+            """assert"": ""$assert"",`n`t" +
+            """tests"": {`n`t`t" +
+                """nightly"": ""$nightly"",`n`t`t" +
+                """weekly"": ""$weekly"",`n`t`t" +
+                """slow"": ""$slow"",`n`t`t" +
+                """awaitsfix"": ""$awaitsFix"",`n`t`t" +
+                """codec"": ""$codec"",`n`t`t" +
+                """docvaluesformat"": ""$docValuesFormat"",`n`t`t" +
+                """postingsformat"": ""$postingsFormat"",`n`t`t" +
+                """directory"": ""$directory"",`n`t`t" +
+                """verbose"": ""$verbose"",`n`t`t" +
+                """multiplier"": ""$multiplier""`n`t" +
+            "}`n" +
+        "}"
         Out-File -filePath "$(Build.ArtifactStagingDirectory)/$(TestSettingsFileName)" -encoding UTF8 -inputObject $fileText
       displayName: 'Persist Test Settings to lucene.testsettings.json'
       condition: and(succeeded(), ne(variables['RunTests'], 'false'))


[lucenenet] 11/13: Codecs: Reverted term vectors readers to use InvalidOperationException always instead of AssertionException only when assert is enabled

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 3ddf3dfce34281fc746ec99cd0d6d0ae2f3fc002
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Sat Aug 22 15:24:56 2020 +0700

    Codecs: Reverted term vectors readers to use InvalidOperationException always instead of AssertionException only when assert is enabled
---
 .../SimpleText/SimpleTextTermVectorsReader.cs              | 14 ++++++++++++--
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs           | 12 +++++++++++-
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs           | 12 +++++++++++-
 3 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
index 729d5b4..edbeccb 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
@@ -540,8 +540,18 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert((_positions != null && _nextPos < _positions.Length) ||
-                    _startOffsets != null && _nextPos < _startOffsets.Length);
+                //if (Debugging.AssertsEnabled) Debugging.Assert((_positions != null && _nextPos < _positions.Length) ||
+                //    _startOffsets != null && _nextPos < _startOffsets.Length);
+
+                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
+                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
+                // part that is checking for an error after reading to the end of the enumerator.
+
+                // In .NET it is more natural to throw an InvalidOperationException in this case, since we would potentially get an
+                // IndexOutOfRangeException if we didn't, which doesn't really provide good feedback as to what the cause is.
+                // This matches the behavior of Lucene 8.x. See #267.
+                if (((_positions != null && _nextPos < _positions.Length) || _startOffsets != null && _nextPos < _startOffsets.Length) == false)
+                    throw new InvalidOperationException("Read past last position");
 
                 if (_positions != null)
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
index 5e23d2c..8f3d99b 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
@@ -740,7 +740,17 @@ namespace Lucene.Net.Codecs.Lucene3x
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+                //if (Debugging.AssertsEnabled) Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+
+                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
+                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
+                // part that is checking for an error after reading to the end of the enumerator.
+
+                // In .NET it is more natural to throw an InvalidOperationException in this case, since we would potentially get an
+                // IndexOutOfRangeException if we didn't, which doesn't really provide good feedback as to what the cause is.
+                // This matches the behavior of Lucene 8.x. See #267.
+                if (((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length) == false)
+                    throw new InvalidOperationException("Read past last position");
 
                 if (positions != null)
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
index d58a59d..1b1a970 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
@@ -733,7 +733,17 @@ namespace Lucene.Net.Codecs.Lucene40
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+                //if (Debugging.AssertsEnabled) Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+
+                // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
+                // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
+                // part that is checking for an error after reading to the end of the enumerator.
+
+                // In .NET it is more natural to throw an InvalidOperationException in this case, since we would potentially get an
+                // IndexOutOfRangeException if we didn't, which doesn't really provide good feedback as to what the cause is.
+                // This matches the behavior of Lucene 8.x. See #267.
+                if (((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length) == false)
+                    throw new InvalidOperationException("Read past last position");
 
                 if (positions != null)
                 {


[lucenenet] 02/13: Lucene.Net.Diagnostics: Added static Debugging.Assert() overloads to allow assertions to be turned on and off in the Release build

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 4b3a849a642fc47396866ba30ee5f585fddaa926
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Thu Aug 13 17:00:10 2020 +0700

    Lucene.Net.Diagnostics: Added static Debugging.Assert() overloads to allow assertions to be turned on and off in the Release build
---
 src/Lucene.Net/Support/Diagnostics/Debugging.cs | 57 +++++++++++++++++++++++--
 1 file changed, 54 insertions(+), 3 deletions(-)

diff --git a/src/Lucene.Net/Support/Diagnostics/Debugging.cs b/src/Lucene.Net/Support/Diagnostics/Debugging.cs
index ecde166..e4ce467 100644
--- a/src/Lucene.Net/Support/Diagnostics/Debugging.cs
+++ b/src/Lucene.Net/Support/Diagnostics/Debugging.cs
@@ -1,4 +1,6 @@
 using Lucene.Net.Util;
+using System;
+using System.Runtime.CompilerServices;
 
 namespace Lucene.Net.Diagnostics
 {
@@ -19,9 +21,9 @@ namespace Lucene.Net.Diagnostics
      * limitations under the License.
      */
 
-    // LUCENENET: This can only be named Debug if we merge it with the Debug
-    // class from Lucene.Net.TestFramework because it is in the same namespace.
-    // But that class is dependent upon AssertionException, which is only for testing.
+    /// <summary>
+    /// Provides a set of methods that help debug your code.
+    /// </summary>
     internal static class Debugging
     {
         /// <summary>
@@ -33,5 +35,54 @@ namespace Lucene.Net.Diagnostics
         /// <see cref="Index.TermVectorsConsumer"/>, and <see cref="Index.TermVectorsConsumerPerField"/>.
         /// </summary>
         public static bool AssertsEnabled { get; set; } = SystemProperties.GetPropertyAsBoolean("assert", false);
+
+        ///// <summary>
+        ///// Checks for a condition; if the condition is <c>false</c>, throws an <see cref="AssertionException"/>.
+        ///// </summary>
+        ///// <param name="condition">The conditional expression to evaluate. If the condition is <c>true</c>, no exception is thrown.</param>
+        //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+        //public static void Assert(bool condition)
+        //{
+        //    if (AssertsEnabled && !condition)
+        //        throw new AssertionException();
+        //}
+
+        ///// <summary>
+        ///// Checks for a condition; if the <paramref name="condition"/> is <c>false</c>, throws an <see cref="AssertionException"/> with the specified <paramref name="message"/>.
+        ///// </summary>
+        ///// <param name="condition">The conditional expression to evaluate. If the condition is <c>true</c>, no exception is thrown.</param>
+        ///// <param name="messageFactory">A delegate to build the message to use.</param>
+        //[MethodImpl(MethodImplOptions.AggressiveInlining)]
+        //public static void Assert(bool condition, Func<string> messageFactory)
+        //{
+        //    if (AssertsEnabled && !condition)
+        //        throw new AssertionException(messageFactory());
+        //}
+
+        /// <summary>
+        /// Checks for a condition; if the condition is <c>false</c>, throws an <see cref="AssertionException"/>.
+        /// </summary>
+        /// <param name="conditionFactory">A delegate that returns the conditional expression to evaluate. If the condition is <c>true</c>, no exception is thrown.</param>
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Assert(Func<bool> conditionFactory)
+        {
+            if (AssertsEnabled && !conditionFactory())
+                throw new AssertionException();
+        }
+
+        /// <summary>
+        /// Checks for a condition if asserts are enabled; if the <paramref name="conditionFactory"/>
+        /// returns <c>false</c>, throws an <see cref="AssertionException"/> with the message returned
+        /// from the specified <paramref name="messageFactory"/>.
+        /// </summary>
+        /// <param name="conditionFactory">A delegate that returns the conditional expression to evaluate. If the condition returned from the factory is <c>true</c>, no exception is thrown.</param>
+        /// <param name="messageFactory">A delegate to build the message to use.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Assert(Func<bool> conditionFactory, Func<string> messageFactory)
+        {
+            if (AssertsEnabled && !conditionFactory())
+                throw new AssertionException(messageFactory());
+        }
     }
 }


[lucenenet] 09/13: Changed all Debugging.Assert() overloads to use bool instead of Func

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit a758ffa4c58eb0ce6fd8f202aaee3c370e988467
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Wed Aug 19 05:37:55 2020 +0700

    Changed all Debugging.Assert() overloads to use bool instead of Func<bool>
---
 .../Analysis/CharFilter/BaseCharFilter.cs          |   2 +-
 .../Analysis/CharFilter/HTMLStripCharFilter.cs     |  22 +-
 .../Analysis/CharFilter/MappingCharFilter.cs       |   2 +-
 .../Analysis/CharFilter/NormalizeCharMap.cs        |   2 +-
 .../Compound/CompoundWordTokenFilterBase.cs        |   2 +-
 .../Analysis/Gl/GalicianStemmer.cs                 |   2 +-
 .../Analysis/Hunspell/Dictionary.cs                |   4 +-
 .../Analysis/Hunspell/Stemmer.cs                   |   4 +-
 .../Analysis/Miscellaneous/ASCIIFoldingFilter.cs   |   2 +-
 .../Miscellaneous/SingleTokenTokenStream.cs        |   4 +-
 .../Analysis/NGram/NGramTokenizer.cs               |   4 +-
 .../Pattern/PatternCaptureGroupTokenFilter.cs      |   2 +-
 .../Analysis/Pt/PortugueseStemmer.cs               |   2 +-
 .../Analysis/Pt/RSLPStemmerBase.cs                 |   2 +-
 .../Analysis/Synonym/SynonymFilter.cs              |  18 +-
 .../Analysis/Synonym/SynonymMap.cs                 |   6 +-
 .../Analysis/Util/CharArrayMap.cs                  |   2 +-
 .../Analysis/Util/CharTokenizer.cs                 |   4 +-
 .../Analysis/Util/CharacterUtils.cs                |  20 +-
 .../Analysis/Util/RollingCharBuffer.cs             |  18 +-
 .../Analysis/Util/SegmentingTokenizerBase.cs       |   2 +-
 .../Analysis/Util/StemmerUtil.cs                   |   4 +-
 .../Analysis/Icu/ICUNormalizer2CharFilter.cs       |   2 +-
 .../Analysis/Icu/Segmentation/ICUTokenizer.cs      |   2 +-
 .../Icu/Segmentation/ICUTokenizerFactory.cs        |   4 +-
 .../Dict/TokenInfoFST.cs                           |   2 +-
 .../GraphvizFormatter.cs                           |   4 +-
 .../JapaneseIterationMarkCharFilter.cs             |   2 +-
 .../JapaneseTokenizer.cs                           |  36 ++--
 .../Tools/BinaryDictionaryWriter.cs                |  24 +--
 .../Tools/ConnectionCostsBuilder.cs                |   6 +-
 .../Tools/ConnectionCostsWriter.cs                 |   4 +-
 .../BeiderMorseFilter.cs                           |   2 +-
 .../ByTask/Utils/AnalyzerFactory.cs                |   2 +-
 src/Lucene.Net.Benchmark/Quality/QualityStats.cs   |   2 +-
 src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs |   2 +-
 .../BlockTerms/BlockTermsReader.cs                 |  32 +--
 .../BlockTerms/BlockTermsWriter.cs                 |  12 +-
 .../BlockTerms/FixedGapTermsIndexReader.cs         |  24 +--
 .../BlockTerms/FixedGapTermsIndexWriter.cs         |   2 +-
 .../BlockTerms/VariableGapTermsIndexReader.cs      |   2 +-
 .../BlockTerms/VariableGapTermsIndexWriter.cs      |   2 +-
 .../Bloom/BloomFilteringPostingsFormat.cs          |   2 +-
 src/Lucene.Net.Codecs/Bloom/FuzzySet.cs            |   2 +-
 .../IntBlock/FixedIntBlockIndexInput.cs            |   4 +-
 .../IntBlock/FixedIntBlockIndexOutput.cs           |   2 +-
 .../IntBlock/VariableIntBlockIndexInput.cs         |   2 +-
 .../IntBlock/VariableIntBlockIndexOutput.cs        |   8 +-
 .../Memory/DirectDocValuesConsumer.cs              |   2 +-
 .../Memory/DirectDocValuesProducer.cs              |   2 +-
 .../Memory/DirectPostingsFormat.cs                 |  52 ++---
 src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs  |  12 +-
 src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs     |   6 +-
 src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs     |   8 +-
 .../Memory/MemoryDocValuesConsumer.cs              |   2 +-
 .../Memory/MemoryDocValuesProducer.cs              |   2 +-
 .../Memory/MemoryPostingsFormat.cs                 |  24 +--
 .../Pulsing/PulsingPostingsFormat.cs               |   2 +-
 .../Pulsing/PulsingPostingsReader.cs               |  10 +-
 .../Pulsing/PulsingPostingsWriter.cs               |  20 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs     |  10 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs     |   8 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs     |   2 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs     |   2 +-
 .../SimpleText/SimpleTextDocValuesReader.cs        |  42 ++--
 .../SimpleText/SimpleTextDocValuesWriter.cs        |  38 ++--
 .../SimpleText/SimpleTextFieldInfosReader.cs       |  28 +--
 .../SimpleText/SimpleTextFieldInfosWriter.cs       |   2 +-
 .../SimpleText/SimpleTextFieldsReader.cs           |  13 +-
 .../SimpleText/SimpleTextFieldsWriter.cs           |   6 +-
 .../SimpleText/SimpleTextLiveDocsFormat.cs         |   6 +-
 .../SimpleText/SimpleTextSegmentInfoReader.cs      |  16 +-
 .../SimpleText/SimpleTextStoredFieldsReader.cs     |  14 +-
 .../SimpleText/SimpleTextTermVectorsReader.cs      |  34 ++--
 .../SimpleText/SimpleTextTermVectorsWriter.cs      |   4 +-
 src/Lucene.Net.Expressions/ExpressionComparator.cs |   4 +-
 src/Lucene.Net.Expressions/ScoreFunctionValues.cs  |   2 +-
 src/Lucene.Net.Facet/DrillDownQuery.cs             |   2 +-
 src/Lucene.Net.Facet/DrillSideways.cs              |   2 +-
 src/Lucene.Net.Facet/DrillSidewaysScorer.cs        |   6 +-
 src/Lucene.Net.Facet/FacetsConfig.cs               |   2 +-
 src/Lucene.Net.Facet/Range/LongRangeCounter.cs     |  10 +-
 src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs      |   4 +-
 .../Taxonomy/Directory/DirectoryTaxonomyWriter.cs  |   6 +-
 .../Taxonomy/Directory/TaxonomyIndexArrays.cs      |   2 +-
 src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs        |   2 +-
 .../Taxonomy/FloatTaxonomyFacets.cs                |   2 +-
 src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs    |   2 +-
 .../AbstractFirstPassGroupingCollector.cs          |  10 +-
 src/Lucene.Net.Grouping/BlockGroupingCollector.cs  |   8 +-
 src/Lucene.Net.Grouping/SearchGroup.cs             |  10 +-
 .../Term/TermGroupFacetCollector.cs                |   4 +-
 .../PostingsHighlight/MultiTermHighlighting.cs     |   4 +-
 .../PostingsHighlight/Passage.cs                   |   4 +-
 .../PostingsHighlight/PostingsHighlighter.cs       |  16 +-
 .../VectorHighlight/BaseFragListBuilder.cs         |   2 +-
 .../VectorHighlight/FieldTermStack.cs              |   2 +-
 src/Lucene.Net.Join/ToChildBlockJoinQuery.cs       |  10 +-
 src/Lucene.Net.Join/ToParentBlockJoinCollector.cs  |   4 +-
 src/Lucene.Net.Join/ToParentBlockJoinQuery.cs      |   4 +-
 .../MemoryIndex.MemoryIndexReader.cs               |  10 +-
 src/Lucene.Net.Memory/MemoryIndex.cs               |  14 +-
 src/Lucene.Net.Misc/Document/LazyDocument.cs       |   6 +-
 .../Index/MultiPassIndexSplitter.cs                |   2 +-
 src/Lucene.Net.Misc/Index/PKIndexSplitter.cs       |   2 +-
 src/Lucene.Net.Misc/Index/Sorter/Sorter.cs         |   4 +-
 .../Index/Sorter/SortingAtomicReader.cs            |   2 +-
 .../Index/Sorter/SortingMergePolicy.cs             |   2 +-
 src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs      |   4 +-
 .../Util/Fst/UpToTwoPositiveIntOutputs.cs          |  36 ++--
 src/Lucene.Net.Queries/BooleanFilter.cs            |   2 +-
 src/Lucene.Net.Queries/CommonTermsQuery.cs         |   2 +-
 .../Processors/AnalyzerQueryNodeProcessor.cs       |  10 +-
 .../Simple/SimpleQueryParser.cs                    |   4 +-
 .../IndexAndTaxonomyRevision.cs                    |   2 +-
 src/Lucene.Net.Replicator/IndexRevision.cs         |   2 +-
 src/Lucene.Net.Replicator/ReplicationClient.cs     |   4 +-
 .../Queries/SortedSetSortField.cs                  |   2 +-
 .../Prefix/AbstractPrefixTreeFilter.cs             |   2 +-
 .../Prefix/AbstractVisitingPrefixTreeFilter.cs     |  16 +-
 .../Prefix/ContainsPrefixTreeFilter.cs             |  12 +-
 src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs         |   4 +-
 .../Prefix/Tree/QuadPrefixTree.cs                  |   4 +-
 .../Prefix/Tree/SpatialPrefixTree.cs               |   4 +-
 .../Prefix/WithinPrefixTreeFilter.cs               |   4 +-
 .../Vector/DistanceValueSource.cs                  |   2 +-
 .../Suggest/Analyzing/AnalyzingSuggester.cs        |  20 +-
 .../Suggest/Analyzing/BlendedInfixSuggester.cs     |   2 +-
 .../Suggest/Analyzing/FSTUtil.cs                   |   8 +-
 .../Suggest/Analyzing/FreeTextSuggester.cs         |  14 +-
 .../Suggest/Analyzing/SuggestStopFilter.cs         |   2 +-
 .../Suggest/Fst/FSTCompletion.cs                   |   2 +-
 .../Suggest/Fst/WFSTCompletionLookup.cs            |   8 +-
 .../Suggest/UnsortedInputIterator.cs               |   6 +-
 .../Analysis/LookaheadTokenFilter.cs               |  22 +-
 .../Analysis/MockCharFilter.cs                     |   2 +-
 .../Analysis/MockReaderWrapper.cs                  |   6 +-
 .../Analysis/MockTokenizer.cs                      |  16 +-
 .../Codecs/Asserting/AssertingDocValuesFormat.cs   |  82 ++++----
 .../Codecs/Asserting/AssertingNormsFormat.cs       |   6 +-
 .../Codecs/Asserting/AssertingPostingsFormat.cs    |  68 +++----
 .../Asserting/AssertingStoredFieldsFormat.cs       |  20 +-
 .../Codecs/Asserting/AssertingTermVectorsFormat.cs |  46 ++---
 .../Compressing/Dummy/DummyCompressingCodec.cs     |   2 +-
 .../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs   |   4 +-
 .../Codecs/Lucene3x/PreFlexRWFieldsWriter.cs       |  10 +-
 .../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs      |   2 +-
 .../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs |   4 +-
 .../Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs  |   6 +-
 .../Codecs/Lucene3x/TermInfosWriter.cs             |  12 +-
 .../Codecs/Lucene40/Lucene40DocValuesWriter.cs     |  16 +-
 .../Codecs/Lucene40/Lucene40FieldInfosWriter.cs    |   8 +-
 .../Codecs/Lucene40/Lucene40PostingsWriter.cs      |  16 +-
 .../Codecs/Lucene40/Lucene40SkipListWriter.cs      |   8 +-
 .../Codecs/Lucene42/Lucene42DocValuesConsumer.cs   |   2 +-
 .../Codecs/Lucene42/Lucene42FieldInfosWriter.cs    |   4 +-
 .../MockVariableIntBlockPostingsFormat.cs          |   2 +-
 .../Codecs/MockRandom/MockRandomPostingsFormat.cs  |   2 +-
 .../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs        |  10 +-
 .../Index/AllDeletedFilterReader.cs                |   2 +-
 .../Index/AssertingAtomicReader.cs                 | 222 ++++++++++-----------
 .../Index/BaseDocValuesFormatTestCase.cs           |  64 +++---
 .../Index/BasePostingsFormatTestCase.cs            |   2 +-
 .../Index/MockRandomMergePolicy.cs                 |   2 +-
 src/Lucene.Net.TestFramework/Index/RandomCodec.cs  |   4 +-
 .../Index/RandomDocumentsWriterPerThreadPool.cs    |   8 +-
 .../Index/RandomIndexWriter.cs                     |   2 +-
 .../Index/ThreadedIndexingAndSearchingTestCase.cs  |   4 +-
 .../Search/AssertingBulkScorer.cs                  |   2 +-
 .../Search/AssertingCollector.cs                   |   2 +-
 .../Search/AssertingScorer.cs                      |   8 +-
 src/Lucene.Net.TestFramework/Search/QueryUtils.cs  |   4 +-
 .../Search/RandomSimilarityProvider.cs             |   2 +-
 .../Search/ShardSearchingTestBase.cs               |  20 +-
 .../Store/MockDirectoryWrapper.cs                  |   6 +-
 .../Support/JavaCompatibility/LuceneTestCase.cs    |   2 +-
 .../Util/Automaton/AutomatonTestUtil.cs            |   4 +-
 .../Util/BaseDocIdSetTestCase.cs                   |   2 +-
 .../Util/FailOnNonBulkMergesInfoStream.cs          |   2 +-
 src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs |   8 +-
 .../Util/LuceneTestCase.cs                         |  14 +-
 .../Util/NullInfoStream.cs                         |   6 +-
 .../Util/TestRuleSetupAndRestoreClassEnv.cs        |  14 +-
 .../Util/ThrottledIndexOutput.cs                   |   2 +-
 .../Analysis/CharFilters/TestMappingCharFilter.cs  |   2 +-
 .../Analysis/Core/TestFactories.cs                 |   2 +-
 .../Analysis/Core/TestRandomChains.cs              |   4 +-
 .../Analysis/Hunspell/TestAllDictionaries.cs       |  12 +-
 .../Analysis/Hunspell/TestAllDictionaries2.cs      |  12 +-
 .../Analysis/Synonym/TestSynonymMapFilter.cs       |   2 +-
 src/Lucene.Net.Tests.Facet/FacetTestCase.cs        |   2 +-
 .../Range/TestRangeFacetCounts.cs                  |   2 +-
 .../Taxonomy/TestTaxonomyFacetSumValueSource.cs    |   2 +-
 src/Lucene.Net.Tests.Facet/TestDrillSideways.cs    |   6 +-
 .../GroupFacetCollectorTest.cs                     |   4 +-
 .../PostingsHighlight/TestPostingsHighlighter.cs   |   6 +-
 src/Lucene.Net.Tests.Join/TestJoinUtil.cs          |   2 +-
 .../Classic/TestQueryParser.cs                     |  14 +-
 .../Flexible/Standard/TestStandardQP.cs            |  10 +-
 .../IndexAndTaxonomyReplicationClientTest.cs       |   2 +-
 .../IndexReplicationClientTest.cs                  |   2 +-
 src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs    |   6 +-
 .../Suggest/Analyzing/AnalyzingSuggesterTest.cs    |   2 +-
 .../Suggest/Analyzing/FuzzySuggesterTest.cs        |   4 +-
 .../Suggest/Analyzing/TestFreeTextSuggester.cs     |   2 +-
 .../Suggest/LookupBenchmarkTest.cs                 |   4 +-
 .../Analysis/TestGraphTokenizers.cs                |   2 +-
 .../Codecs/Lucene41/TestBlockPostingsFormat3.cs    |   2 +-
 .../Codecs/PerField/TestPerFieldDocValuesFormat.cs |   2 +-
 .../Index/TestBackwardsCompatibility.cs            |   2 +-
 .../Index/TestBackwardsCompatibility3x.cs          |   2 +-
 src/Lucene.Net.Tests/Index/TestCodecs.cs           |   6 +-
 src/Lucene.Net.Tests/Index/TestIndexWriter.cs      |   4 +-
 .../Index/TestIndexWriterMerging.cs                |   2 +-
 src/Lucene.Net.Tests/Index/TestIndexableField.cs   |   4 +-
 src/Lucene.Net.Tests/Index/TestLongPostings.cs     |   4 +-
 src/Lucene.Net.Tests/Index/TestNRTThreads.cs       |   2 +-
 src/Lucene.Net.Tests/Index/TestPayloads.cs         |   2 +-
 .../Index/TestPayloadsOnVectors.cs                 |   4 +-
 src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs  |   8 +-
 src/Lucene.Net.Tests/Index/TestStressIndexing2.cs  |   4 +-
 src/Lucene.Net.Tests/Index/TestStressNRT.cs        |   4 +-
 src/Lucene.Net.Tests/Index/TestTermsEnum.cs        |   2 +-
 .../Search/Spans/MultiSpansWrapper.cs              |   2 +-
 src/Lucene.Net.Tests/Search/TestBooleanScorer.cs   |   2 +-
 .../Search/TestConstantScoreQuery.cs               |   2 +-
 src/Lucene.Net.Tests/Search/TestFieldCache.cs      |   2 +-
 src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs |  10 +-
 .../Search/TestMultiThreadTermVectors.cs           |   2 +-
 .../Search/TestNumericRangeQuery32.cs              |   4 +-
 .../Search/TestNumericRangeQuery64.cs              |   4 +-
 .../Search/TestTimeLimitingCollector.cs            |   2 +-
 .../Util/Automaton/TestUTF32ToUTF8.cs              |   6 +-
 src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs          |   2 +-
 .../Util/Packed/TestEliasFanoDocIdSet.cs           |   2 +-
 .../Util/Packed/TestEliasFanoSequence.cs           |   6 +-
 src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs      |   2 +-
 src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs      |   2 +-
 src/Lucene.Net/Analysis/NumericTokenStream.cs      |   2 +-
 src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs  |   4 +-
 src/Lucene.Net/Analysis/Tokenizer.cs               |   2 +-
 src/Lucene.Net/Codecs/BlockTermState.cs            |   2 +-
 src/Lucene.Net/Codecs/BlockTreeTermsReader.cs      | 162 +++++++--------
 src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs      |  66 +++---
 src/Lucene.Net/Codecs/CodecUtil.cs                 |   2 +-
 .../CompressingStoredFieldsIndexWriter.cs          |   8 +-
 .../Compressing/CompressingStoredFieldsReader.cs   |  18 +-
 .../Compressing/CompressingStoredFieldsWriter.cs   |  16 +-
 .../Compressing/CompressingTermVectorsReader.cs    |  20 +-
 .../Compressing/CompressingTermVectorsWriter.cs    |  38 ++--
 .../Codecs/Compressing/CompressionMode.cs          |   6 +-
 src/Lucene.Net/Codecs/Compressing/LZ4.cs           |  18 +-
 src/Lucene.Net/Codecs/DocValuesConsumer.cs         |   4 +-
 src/Lucene.Net/Codecs/FieldsConsumer.cs            |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs   |  40 ++--
 .../Codecs/Lucene3x/Lucene3xNormsProducer.cs       |   6 +-
 .../Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs   |   6 +-
 .../Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs  |   4 +-
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs   |  14 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs  |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs  |   4 +-
 .../Codecs/Lucene3x/SegmentTermPositions.cs        |   2 +-
 src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs       |   6 +-
 src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs  |  10 +-
 src/Lucene.Net/Codecs/Lucene40/BitVector.cs        |  24 +--
 .../Codecs/Lucene40/Lucene40LiveDocsFormat.cs      |   8 +-
 .../Codecs/Lucene40/Lucene40PostingsFormat.cs      |   2 +-
 .../Codecs/Lucene40/Lucene40PostingsReader.cs      |  36 ++--
 .../Codecs/Lucene40/Lucene40StoredFieldsReader.cs  |   8 +-
 .../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs  |  10 +-
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs   |  24 +--
 .../Codecs/Lucene40/Lucene40TermVectorsWriter.cs   |  18 +-
 src/Lucene.Net/Codecs/Lucene41/ForUtil.cs          |  22 +-
 .../Codecs/Lucene41/Lucene41PostingsFormat.cs      |   4 +-
 .../Codecs/Lucene41/Lucene41PostingsReader.cs      |  22 +-
 .../Codecs/Lucene41/Lucene41PostingsWriter.cs      |  12 +-
 .../Codecs/Lucene41/Lucene41SkipReader.cs          |   2 +-
 .../Codecs/Lucene42/Lucene42NormsConsumer.cs       |   4 +-
 .../Codecs/Lucene45/Lucene45DocValuesConsumer.cs   |   4 +-
 .../Codecs/Lucene46/Lucene46FieldInfosWriter.cs    |   4 +-
 src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs      |   2 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs  |   2 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs  |   2 +-
 .../Codecs/PerField/PerFieldDocValuesFormat.cs     |  10 +-
 .../Codecs/PerField/PerFieldPostingsFormat.cs      |   8 +-
 src/Lucene.Net/Codecs/PostingsConsumer.cs          |   2 +-
 src/Lucene.Net/Codecs/TermVectorsWriter.cs         |  16 +-
 src/Lucene.Net/Codecs/TermsConsumer.cs             |  10 +-
 src/Lucene.Net/Index/AtomicReader.cs               |   8 +-
 src/Lucene.Net/Index/AtomicReaderContext.cs        |   2 +-
 src/Lucene.Net/Index/AutomatonTermsEnum.cs         |   8 +-
 src/Lucene.Net/Index/BitsSlice.cs                  |   4 +-
 src/Lucene.Net/Index/BufferedUpdatesStream.cs      |  48 ++---
 src/Lucene.Net/Index/ByteSliceReader.cs            |  16 +-
 src/Lucene.Net/Index/ByteSliceWriter.cs            |  12 +-
 src/Lucene.Net/Index/CheckIndex.cs                 |  28 +--
 src/Lucene.Net/Index/CompositeReader.cs            |   4 +-
 src/Lucene.Net/Index/CompositeReaderContext.cs     |   4 +-
 src/Lucene.Net/Index/ConcurrentMergeScheduler.cs   |   2 +-
 src/Lucene.Net/Index/DirectoryReader.cs            |   6 +-
 src/Lucene.Net/Index/DocFieldProcessor.cs          |   8 +-
 src/Lucene.Net/Index/DocTermOrds.cs                |  20 +-
 src/Lucene.Net/Index/DocValuesFieldUpdates.cs      |   4 +-
 src/Lucene.Net/Index/DocValuesProcessor.cs         |   4 +-
 src/Lucene.Net/Index/DocumentsWriter.cs            |  38 ++--
 src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs |   6 +-
 .../Index/DocumentsWriterFlushControl.cs           |  72 +++----
 src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs  |  34 ++--
 src/Lucene.Net/Index/DocumentsWriterPerThread.cs   |  30 +--
 .../Index/DocumentsWriterPerThreadPool.cs          |  24 +--
 .../Index/DocumentsWriterStallControl.cs           |   8 +-
 src/Lucene.Net/Index/FieldInfo.cs                  |  28 +--
 src/Lucene.Net/Index/FieldInfos.cs                 |  10 +-
 src/Lucene.Net/Index/FilteredTermsEnum.cs          |   6 +-
 src/Lucene.Net/Index/FlushPolicy.cs                |   6 +-
 src/Lucene.Net/Index/FreqProxTermsWriter.cs        |   2 +-
 .../Index/FreqProxTermsWriterPerField.cs           |  48 ++---
 src/Lucene.Net/Index/FrozenBufferedUpdates.cs      |   6 +-
 src/Lucene.Net/Index/IndexFileDeleter.cs           |  42 ++--
 src/Lucene.Net/Index/IndexFileNames.cs             |   4 +-
 src/Lucene.Net/Index/IndexFormatTooNewException.cs |   2 +-
 src/Lucene.Net/Index/IndexFormatTooOldException.cs |   4 +-
 src/Lucene.Net/Index/IndexWriter.cs                | 146 +++++++-------
 src/Lucene.Net/Index/LogMergePolicy.cs             |   8 +-
 src/Lucene.Net/Index/MergePolicy.cs                |   8 +-
 src/Lucene.Net/Index/MergeState.cs                 |   4 +-
 src/Lucene.Net/Index/MultiBits.cs                  |  12 +-
 src/Lucene.Net/Index/MultiDocValues.cs             |  10 +-
 src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs  |   4 +-
 src/Lucene.Net/Index/MultiDocsEnum.cs              |   2 +-
 src/Lucene.Net/Index/MultiFields.cs                |  10 +-
 src/Lucene.Net/Index/MultiTerms.cs                 |   2 +-
 src/Lucene.Net/Index/MultiTermsEnum.cs             |  20 +-
 src/Lucene.Net/Index/NormsConsumer.cs              |   6 +-
 .../Index/NumericDocValuesFieldUpdates.cs          |   2 +-
 src/Lucene.Net/Index/OrdTermState.cs               |   2 +-
 src/Lucene.Net/Index/ParallelCompositeReader.cs    |   2 +-
 src/Lucene.Net/Index/PrefixCodedTerms.cs           |   4 +-
 src/Lucene.Net/Index/ReadersAndUpdates.cs          |  48 ++---
 src/Lucene.Net/Index/SegmentCoreReaders.cs         |   6 +-
 src/Lucene.Net/Index/SegmentDocValues.cs           |   4 +-
 src/Lucene.Net/Index/SegmentInfo.cs                |   4 +-
 src/Lucene.Net/Index/SegmentInfos.cs               |  10 +-
 src/Lucene.Net/Index/SegmentMerger.cs              |   4 +-
 src/Lucene.Net/Index/SegmentReader.cs              |  12 +-
 src/Lucene.Net/Index/SimpleMergedSegmentWarmer.cs  |   2 +-
 .../Index/SingletonSortedSetDocValues.cs           |   2 +-
 src/Lucene.Net/Index/SlowCompositeReaderWrapper.cs |   4 +-
 src/Lucene.Net/Index/SnapshotDeletionPolicy.cs     |   2 +-
 src/Lucene.Net/Index/SortedDocValuesTermsEnum.cs   |   4 +-
 src/Lucene.Net/Index/SortedDocValuesWriter.cs      |   4 +-
 .../Index/SortedSetDocValuesTermsEnum.cs           |   4 +-
 src/Lucene.Net/Index/SortedSetDocValuesWriter.cs   |   4 +-
 src/Lucene.Net/Index/StandardDirectoryReader.cs    |   6 +-
 src/Lucene.Net/Index/StoredFieldsProcessor.cs      |   6 +-
 src/Lucene.Net/Index/TermContext.cs                |  12 +-
 src/Lucene.Net/Index/TermVectorsConsumer.cs        |  12 +-
 .../Index/TermVectorsConsumerPerField.cs           |  12 +-
 src/Lucene.Net/Index/TermsHashPerField.cs          |   6 +-
 .../ThreadAffinityDocumentsWriterThreadPool.cs     |   6 +-
 src/Lucene.Net/Search/CachingWrapperFilter.cs      |   2 +-
 src/Lucene.Net/Search/CollectionStatistics.cs      |   8 +-
 src/Lucene.Net/Search/ConstantScoreAutoRewrite.cs  |   6 +-
 src/Lucene.Net/Search/ConstantScoreQuery.cs        |  12 +-
 src/Lucene.Net/Search/DisjunctionScorer.cs         |   4 +-
 src/Lucene.Net/Search/DocIdSetIterator.cs          |   8 +-
 src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs    |   2 +-
 src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs  |   2 +-
 src/Lucene.Net/Search/ExactPhraseScorer.cs         |   2 +-
 src/Lucene.Net/Search/FieldCacheImpl.cs            |  12 +-
 src/Lucene.Net/Search/FieldCacheRangeFilter.cs     |   4 +-
 src/Lucene.Net/Search/FieldCacheRewriteMethod.cs   |   2 +-
 src/Lucene.Net/Search/FieldComparator.cs           |  12 +-
 src/Lucene.Net/Search/FieldValueHitQueue.cs        |   8 +-
 src/Lucene.Net/Search/FilteredQuery.cs             |   8 +-
 src/Lucene.Net/Search/FuzzyTermsEnum.cs            |   2 +-
 src/Lucene.Net/Search/IndexSearcher.cs             |   6 +-
 src/Lucene.Net/Search/MinShouldMatchSumScorer.cs   |   4 +-
 src/Lucene.Net/Search/MultiPhraseQuery.cs          |   4 +-
 .../Search/MultiTermQueryWrapperFilter.cs          |   2 +-
 src/Lucene.Net/Search/NumericRangeQuery.cs         |  14 +-
 src/Lucene.Net/Search/PhraseQuery.cs               |   6 +-
 src/Lucene.Net/Search/QueryRescorer.cs             |   2 +-
 src/Lucene.Net/Search/ReferenceManager.cs          |   6 +-
 src/Lucene.Net/Search/ReqOptSumScorer.cs           |   4 +-
 src/Lucene.Net/Search/ScoringRewrite.cs            |  10 +-
 src/Lucene.Net/Search/SearcherManager.cs           |   4 +-
 .../Search/Similarities/SimilarityBase.cs          |   2 +-
 src/Lucene.Net/Search/SloppyPhraseScorer.cs        |   4 +-
 src/Lucene.Net/Search/SortField.cs                 |   2 +-
 src/Lucene.Net/Search/SortRescorer.cs              |   2 +-
 src/Lucene.Net/Search/Spans/NearSpansOrdered.cs    |   6 +-
 src/Lucene.Net/Search/Spans/SpanFirstQuery.cs      |   2 +-
 .../Search/Spans/SpanPositionRangeQuery.cs         |   2 +-
 src/Lucene.Net/Search/Spans/TermSpans.cs           |   2 +-
 src/Lucene.Net/Search/TermCollectingRewrite.cs     |   2 +-
 src/Lucene.Net/Search/TermQuery.cs                 |  10 +-
 src/Lucene.Net/Search/TermScorer.cs                |   2 +-
 src/Lucene.Net/Search/TermStatistics.cs            |   4 +-
 src/Lucene.Net/Search/TopDocs.cs                   |  10 +-
 src/Lucene.Net/Search/TopScoreDocCollector.cs      |  12 +-
 src/Lucene.Net/Search/TopTermsRewrite.cs           |  18 +-
 src/Lucene.Net/Store/BaseDirectory.cs              |   2 +-
 src/Lucene.Net/Store/BufferedIndexInput.cs         |   2 +-
 src/Lucene.Net/Store/ByteArrayDataOutput.cs        |   4 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs       |   8 +-
 src/Lucene.Net/Store/CompoundFileDirectory.cs      |   8 +-
 src/Lucene.Net/Store/CompoundFileWriter.cs         |  18 +-
 src/Lucene.Net/Store/DataInput.cs                  |   2 +-
 src/Lucene.Net/Store/DataOutput.cs                 |   4 +-
 src/Lucene.Net/Store/IOContext.cs                  |   6 +-
 src/Lucene.Net/Store/MMapDirectory.cs              |   2 +-
 src/Lucene.Net/Store/NIOFSDirectory.cs             |   6 +-
 src/Lucene.Net/Store/RAMOutputStream.cs            |   2 +-
 src/Lucene.Net/Store/SimpleFSDirectory.cs          |   2 +-
 src/Lucene.Net/Support/Collections.cs              |   2 +-
 src/Lucene.Net/Support/Diagnostics/Debugging.cs    |  65 +++---
 src/Lucene.Net/Util/ArrayUtil.cs                   |  40 ++--
 src/Lucene.Net/Util/AttributeSource.cs             |   2 +-
 src/Lucene.Net/Util/Automaton/Automaton.cs         |   4 +-
 src/Lucene.Net/Util/Automaton/BasicOperations.cs   |   8 +-
 src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs |   8 +-
 .../Util/Automaton/DaciukMihovAutomatonBuilder.cs  |  14 +-
 .../Util/Automaton/Lev1ParametricDescription.cs    |   4 +-
 .../Util/Automaton/Lev1TParametricDescription.cs   |   4 +-
 .../Util/Automaton/Lev2ParametricDescription.cs    |   4 +-
 .../Util/Automaton/Lev2TParametricDescription.cs   |   4 +-
 .../Util/Automaton/LevenshteinAutomata.cs          |   2 +-
 src/Lucene.Net/Util/Automaton/SortedIntSet.cs      |   2 +-
 src/Lucene.Net/Util/Automaton/State.cs             |   2 +-
 src/Lucene.Net/Util/Automaton/Transition.cs        |   6 +-
 src/Lucene.Net/Util/Automaton/UTF32ToUTF8.cs       |   4 +-
 src/Lucene.Net/Util/BroadWord.cs                   |   4 +-
 src/Lucene.Net/Util/ByteBlockPool.cs               |   2 +-
 src/Lucene.Net/Util/BytesRef.cs                    |  12 +-
 src/Lucene.Net/Util/BytesRefArray.cs               |   2 +-
 src/Lucene.Net/Util/BytesRefHash.cs                |  38 ++--
 src/Lucene.Net/Util/CharsRef.cs                    |   4 +-
 src/Lucene.Net/Util/FilterIterator.cs              |   2 +-
 src/Lucene.Net/Util/FixedBitSet.cs                 |  30 +--
 src/Lucene.Net/Util/Fst/Builder.cs                 |  44 ++--
 src/Lucene.Net/Util/Fst/ByteSequenceOutputs.cs     |  22 +-
 src/Lucene.Net/Util/Fst/BytesRefFSTEnum.cs         |   2 +-
 src/Lucene.Net/Util/Fst/BytesStore.cs              |  18 +-
 src/Lucene.Net/Util/Fst/CharSequenceOutputs.cs     |  22 +-
 src/Lucene.Net/Util/Fst/FST.cs                     |  76 +++----
 src/Lucene.Net/Util/Fst/FSTEnum.cs                 |  20 +-
 src/Lucene.Net/Util/Fst/IntSequenceOutputs.cs      |  22 +-
 src/Lucene.Net/Util/Fst/IntsRefFSTEnum.cs          |   2 +-
 src/Lucene.Net/Util/Fst/NoOutputs.cs               |  16 +-
 src/Lucene.Net/Util/Fst/NodeHash.cs                |   2 +-
 src/Lucene.Net/Util/Fst/PairOutputs.cs             |  18 +-
 src/Lucene.Net/Util/Fst/PositiveIntOutputs.cs      |  24 +--
 src/Lucene.Net/Util/Fst/Util.cs                    |  12 +-
 src/Lucene.Net/Util/IndexableBinaryStringTools.cs  |   4 +-
 src/Lucene.Net/Util/InfoStream.cs                  |   2 +-
 src/Lucene.Net/Util/IntBlockPool.cs                |  14 +-
 src/Lucene.Net/Util/IntsRef.cs                     |   4 +-
 src/Lucene.Net/Util/LongBitSet.cs                  |  30 +--
 src/Lucene.Net/Util/LongsRef.cs                    |   4 +-
 src/Lucene.Net/Util/MergedIterator.cs              |   2 +-
 src/Lucene.Net/Util/OfflineSorter.cs               |  12 +-
 src/Lucene.Net/Util/OpenBitSet.cs                  |  34 ++--
 src/Lucene.Net/Util/PForDeltaDocIdSet.cs           |  28 +--
 .../Util/Packed/AbstractAppendingLongBuffer.cs     |  10 +-
 .../Util/Packed/AbstractBlockPackedWriter.cs       |   2 +-
 src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs |   6 +-
 src/Lucene.Net/Util/Packed/BlockPackedReader.cs    |   2 +-
 .../Util/Packed/BlockPackedReaderIterator.cs       |  12 +-
 src/Lucene.Net/Util/Packed/BlockPackedWriter.cs    |   2 +-
 src/Lucene.Net/Util/Packed/BulkOperation.cs        |   4 +-
 src/Lucene.Net/Util/Packed/BulkOperationPacked.cs  |  16 +-
 src/Lucene.Net/Util/Packed/Direct16.cs             |  14 +-
 src/Lucene.Net/Util/Packed/Direct32.cs             |  14 +-
 src/Lucene.Net/Util/Packed/Direct64.cs             |  12 +-
 src/Lucene.Net/Util/Packed/Direct8.cs              |  14 +-
 src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs     |  28 +--
 src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs     |   4 +-
 src/Lucene.Net/Util/Packed/GrowableWriter.cs       |   2 +-
 .../Util/Packed/MonotonicAppendingLongBuffer.cs    |   2 +-
 .../Util/Packed/MonotonicBlockPackedReader.cs      |   2 +-
 .../Util/Packed/MonotonicBlockPackedWriter.cs      |   4 +-
 src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs  |  12 +-
 src/Lucene.Net/Util/Packed/Packed64.cs             |  36 ++--
 src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs  |  40 ++--
 src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs   |  12 +-
 src/Lucene.Net/Util/Packed/PackedDataInput.cs      |   2 +-
 src/Lucene.Net/Util/Packed/PackedDataOutput.cs     |   2 +-
 src/Lucene.Net/Util/Packed/PackedInts.cs           |  70 +++----
 src/Lucene.Net/Util/Packed/PackedReaderIterator.cs |   8 +-
 src/Lucene.Net/Util/Packed/PackedWriter.cs         |   6 +-
 src/Lucene.Net/Util/Packed/PagedMutable.cs         |   2 +-
 src/Lucene.Net/Util/PagedBytes.cs                  |  14 +-
 src/Lucene.Net/Util/QueryBuilder.cs                |  12 +-
 src/Lucene.Net/Util/RamUsageEstimator.cs           |  12 +-
 src/Lucene.Net/Util/RecyclingByteBlockAllocator.cs |   6 +-
 src/Lucene.Net/Util/RecyclingIntBlockAllocator.cs  |   6 +-
 src/Lucene.Net/Util/RollingBuffer.cs               |   6 +-
 src/Lucene.Net/Util/SentinelIntSet.cs              |   4 +-
 src/Lucene.Net/Util/Sorter.cs                      |   2 +-
 src/Lucene.Net/Util/TimSorter.cs                   |  18 +-
 src/Lucene.Net/Util/UnicodeUtil.cs                 |   4 +-
 src/Lucene.Net/Util/WAH8DocIdSet.cs                |  54 ++---
 .../TestICUPostingsHighlighter.cs                  |   6 +-
 504 files changed, 2598 insertions(+), 2598 deletions(-)

diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
index f490dc0..f566eef 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
@@ -114,7 +114,7 @@ namespace Lucene.Net.Analysis.CharFilters
             }
 
             int offset = offsets[(size == 0) ? 0 : size - 1];
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => size == 0 || off >= offset,
+            if (Debugging.AssertsEnabled) Debugging.Assert(size == 0 || off >= offset,
                 () => "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
 
             if (size == 0 || off != offsets[size - 1])
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
index 611e72b..5bff511 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
@@ -30953,7 +30953,7 @@ namespace Lucene.Net.Analysis.CharFilters
             /// </summary>
             internal int NextChar()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !IsRead, () => "Attempting to read past the end of a segment.");
+                if (Debugging.AssertsEnabled) Debugging.Assert(!IsRead, () => "Attempting to read past the end of a segment.");
                 return m_buf[pos++];
             }
 
@@ -31378,7 +31378,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing code point '" + decimalCharRef + "'");
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing code point '" + decimalCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31638,7 +31638,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing hex code point '" + hexCharRef + "'");
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing hex code point '" + hexCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31901,7 +31901,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31910,7 +31910,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
                             }
                             // add (previously matched input length) + (this match length) - (substitution length)
                             cumulativeDiff += inputSegment.Length + YyLength - 2;
@@ -31932,7 +31932,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31941,7 +31941,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing low surrogate '"
                                             + surrogatePair.Substring(9, 14 - 9) + "'");
                             }
                             if (char.IsLowSurrogate(lowSurrogate))
@@ -31973,7 +31973,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -31986,7 +31986,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(10, 14 - 10) + "'");
                                 }
                                 // add (previously matched input length) + (this match length) - (substitution length)
@@ -32013,7 +32013,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
+                                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -32025,7 +32025,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(9, 14 - 9) + "'");
                                 }
                                 if (char.IsLowSurrogate(lowSurrogate))
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
index a921887..dec5db1 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
@@ -136,7 +136,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         if (!FST.TargetHasArcs(arc))
                         {
                             // Fast pass for single character match:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                             lastMatchLen = 1;
                             lastMatch = arc.Output;
                         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
index 7186c94..e3963d2 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
@@ -54,7 +54,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         map.ReadFirstRealTargetArc(scratchArc.Target, scratchArc, fstReader);
                         while (true)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchArc.Label != FST.END_LABEL);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(scratchArc.Label != FST.END_LABEL);
                             cachedRootArcs[Convert.ToChar((char)scratchArc.Label)] = (new FST.Arc<CharsRef>()).CopyFrom(scratchArc);
                             if (scratchArc.IsLast)
                             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
index b60791e..bf5ecab 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
@@ -110,7 +110,7 @@ namespace Lucene.Net.Analysis.Compound
         {
             if (m_tokens.Count > 0)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => current != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(current != null);
                 CompoundToken token = m_tokens.Dequeue();
                 RestoreState(current); // keep all other attributes untouched
                 m_termAtt.SetEmpty().Append(token.Text);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
index bf49cde..5d41c25 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis.Gl
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
+            if (Debugging.AssertsEnabled) Debugging.Assert(s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = unification.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
index 305f0d1..0f4e984 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
@@ -375,7 +375,7 @@ namespace Lucene.Net.Analysis.Hunspell
                 strip.CopyTo(0, stripData, currentOffset, strip.Length - 0);
                 currentOffset += strip.Length;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentIndex == seenStrips.Count);
+            if (Debugging.AssertsEnabled) Debugging.Assert(currentIndex == seenStrips.Count);
             stripOffsets[currentIndex] = currentOffset;
         }
 
@@ -424,7 +424,7 @@ namespace Lucene.Net.Analysis.Hunspell
 
             for (int i = 0; i < numLines; i++)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => affixWriter.Position == currentAffix << 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(affixWriter.Position == currentAffix << 3);
                 string line = reader.ReadLine();
                 string[] ruleArgs = whitespacePattern.Split(line).TrimEnd();
 
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
index 4ad0ee1..9388316 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
@@ -210,7 +210,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => prevFlag >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, false);
                         }
                         else
@@ -279,7 +279,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => prevFlag >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, previousWasPrefix);
                         }
                         else
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
index aa76247..f219184 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Analysis.Miscellaneous
         {
             if (state != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => preserveOriginal, () => "state should only be captured if preserveOriginal is true");
+                if (Debugging.AssertsEnabled) Debugging.Assert(preserveOriginal, () => "state should only be captured if preserveOriginal is true");
                 RestoreState(state);
                 posIncAttr.PositionIncrement = 0;
                 state = null;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
index 225fae8..3e384bd 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
@@ -35,11 +35,11 @@ namespace Lucene.Net.Analysis.Miscellaneous
         public SingleTokenTokenStream(Token token) 
             : base(Token.TOKEN_ATTRIBUTE_FACTORY)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => token != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(token != null);
             this.singleToken = (Token)token.Clone();
 
             tokenAtt = AddAttribute<ICharTermAttribute>();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => tokenAtt is Token);
+            if (Debugging.AssertsEnabled) Debugging.Assert(tokenAtt is Token);
         }
 
         public override sealed bool IncrementToken()
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
index 60bc879..d03c06d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
@@ -232,7 +232,7 @@ namespace Lucene.Net.Analysis.NGram
                 {
                     if (bufferStart + 1 + minGram > bufferEnd)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => exhausted);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(exhausted);
                         return false;
                     }
                     Consume();
@@ -295,7 +295,7 @@ namespace Lucene.Net.Analysis.NGram
         public override sealed void End()
         {
             base.End();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => bufferStart <= bufferEnd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(bufferStart <= bufferEnd);
             int endOffset = offset;
             for (int i = bufferStart; i < bufferEnd; ++i)
             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
index e901768..1b6f976 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
@@ -155,7 +155,7 @@ namespace Lucene.Net.Analysis.Pattern
         {
             if (currentMatcher != -1 && NextCapture())
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != null);
                 ClearAttributes();
                 RestoreState(state);
                 int start = matchers[currentMatcher].Groups[currentGroup[currentMatcher]].Index;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
index 8943de0..0d0a94c 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
@@ -46,7 +46,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
+            if (Debugging.AssertsEnabled) Debugging.Assert(s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = adverb.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
index 594c88b..108a87a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
@@ -305,7 +305,7 @@ namespace Lucene.Net.Analysis.Pt
             {
                 throw new Exception("Illegal Step header specified at line " /*+ r.LineNumber*/); // TODO Line number
             }
-            //if (Debugging.AssertsEnabled) Debugging.Assert(() => headerPattern.GetGroupNumbers().Length == 4); // Not possible to read the number of groups that matched in .NET
+            //if (Debugging.AssertsEnabled) Debugging.Assert(headerPattern.GetGroupNumbers().Length == 4); // Not possible to read the number of groups that matched in .NET
             string name = matcher.Groups[1].Value;
             int min = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture);
             int type = int.Parse(matcher.Groups[3].Value, CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
index a0c0786..e118268 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis.Synonym
 
             public virtual CharsRef PullNext()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(upto < count);
                 lastEndOffset = endOffsets[upto];
                 lastPosLength = posLengths[upto];
                 CharsRef result = outputs[upto++];
@@ -306,7 +306,7 @@ namespace Lucene.Net.Analysis.Synonym
             nextWrite = RollIncr(nextWrite);
 
             // Buffer head should never catch up to tail:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextWrite != nextRead);
+            if (Debugging.AssertsEnabled) Debugging.Assert(nextWrite != nextRead);
         }
 
         /*
@@ -325,7 +325,7 @@ namespace Lucene.Net.Analysis.Synonym
         {
             //System.out.println("\nS: parse");
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputSkipCount == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(inputSkipCount == 0);
 
             int curNextRead = nextRead;
 
@@ -337,7 +337,7 @@ namespace Lucene.Net.Analysis.Synonym
             BytesRef pendingOutput = fst.Outputs.NoOutput;
             fst.GetFirstArc(scratchArc);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchArc.Output == fst.Outputs.NoOutput);
+            if (Debugging.AssertsEnabled) Debugging.Assert(scratchArc.Output == fst.Outputs.NoOutput);
 
             int tokenCount = 0;
 
@@ -364,7 +364,7 @@ namespace Lucene.Net.Analysis.Synonym
                     else
                     {
                         //System.out.println("  input.incrToken");
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => futureInputs[nextWrite].consumed);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(futureInputs[nextWrite].consumed);
                         // Not correct: a syn match whose output is longer
                         // than its input can set future inputs keepOrig
                         // to true:
@@ -480,7 +480,7 @@ namespace Lucene.Net.Analysis.Synonym
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => finished);
+                if (Debugging.AssertsEnabled) Debugging.Assert(finished);
             }
 
             //System.out.println("  parse done inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead + " nextWrite=" + nextWrite);
@@ -510,7 +510,7 @@ namespace Lucene.Net.Analysis.Synonym
                         int outputLen = chIDX - lastStart;
                         // Caller is not allowed to have empty string in
                         // the output:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => outputLen > 0, () => "output contains empty string: " + scratchChars);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(outputLen > 0, () => "output contains empty string: " + scratchChars);
                         int endOffset;
                         int posLen;
                         if (chIDX == chEnd && lastStart == scratchChars.Offset)
@@ -536,7 +536,7 @@ namespace Lucene.Net.Analysis.Synonym
                         lastStart = 1 + chIDX;
                         //System.out.println("  slot=" + outputUpto + " keepOrig=" + keepOrig);
                         outputUpto = RollIncr(outputUpto);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => futureOutputs[outputUpto].posIncr == 1, () => "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(futureOutputs[outputUpto].posIncr == 1, () => "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
                     }
                 }
             }
@@ -602,7 +602,7 @@ namespace Lucene.Net.Analysis.Synonym
                         {
                             // Pass-through case: return token we just pulled
                             // but didn't capture:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputSkipCount == 1, () => "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(inputSkipCount == 1, () => "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
                         }
                         input.Reset();
                         if (outputs.count > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
index 539233e..2e2e9b5 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
@@ -175,8 +175,8 @@ namespace Lucene.Net.Analysis.Synonym
 
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => !HasHoles(input), () => "input has holes: " + input);
-                    Debugging.Assert(() => !HasHoles(output), () => "output has holes: " + output);
+                    Debugging.Assert(!HasHoles(input), () => "input has holes: " + input);
+                    Debugging.Assert(!HasHoles(output), () => "output has holes: " + output);
                 }
 
                 //System.out.println("fmap.add input=" + input + " numInputWords=" + numInputWords + " output=" + output + " numOutputWords=" + numOutputWords);
@@ -284,7 +284,7 @@ namespace Lucene.Net.Analysis.Synonym
 
                     scratch.Grow(estimatedSize);
                     scratchOutput.Reset(scratch.Bytes, scratch.Offset, scratch.Bytes.Length);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => scratch.Offset == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(scratch.Offset == 0);
 
                     // now write our output data:
                     int count = 0;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
index a4be3e6..b2dd01a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
@@ -632,7 +632,7 @@ namespace Lucene.Net.Analysis.Util
 
         private void Rehash()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => keys.Length == values.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(keys.Length == values.Length);
             int newSize = 2 * keys.Length;
             char[][] oldkeys = keys;
             MapValue[] oldvalues = values;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
index 9eda606..bfb15ba 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
@@ -169,7 +169,7 @@ namespace Lucene.Net.Analysis.Util
                 {
                     if (length == 0) // start of token
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => start == -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(start == -1);
                         start = offset + bufferIndex - charCount;
                         end = start;
                     } // check if a supplementary could run out of bounds
@@ -191,7 +191,7 @@ namespace Lucene.Net.Analysis.Util
             }
 
             termAtt.Length = length;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => start != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(start != -1);
             offsetAtt.SetOffset(CorrectOffset(start), finalOffset = CorrectOffset(end));
             return true;
         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
index 3822951..1982064 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
@@ -178,8 +178,8 @@ namespace Lucene.Net.Analysis.Util
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => buffer.Length >= length);
-                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                Debugging.Assert(buffer.Length >= length);
+                Debugging.Assert(offset <= 0 && offset <= buffer.Length);
             }
 
             // Slight optimization, eliminating a few method calls internally
@@ -212,8 +212,8 @@ namespace Lucene.Net.Analysis.Util
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => buffer.Length >= length);
-                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                Debugging.Assert(buffer.Length >= length);
+                Debugging.Assert(offset <= 0 && offset <= buffer.Length);
             }
 
             // Slight optimization, eliminating a few method calls internally
@@ -355,7 +355,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Buffer.Length >= 2);
+                if (Debugging.AssertsEnabled) Debugging.Assert(buffer.Buffer.Length >= 2);
                 if (numChars < 2 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 2 and <= the buffer size");
@@ -476,7 +476,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Buffer.Length >= 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(buffer.Buffer.Length >= 1);
                 if (numChars < 1 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 1 and <= the buffer size");
@@ -541,8 +541,8 @@ namespace Lucene.Net.Analysis.Util
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => buffer.Length >= limit);
-                    Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                    Debugging.Assert(buffer.Length >= limit);
+                    Debugging.Assert(offset <= 0 && offset <= buffer.Length);
                 }
 
                 for (int i = offset; i < limit;)
@@ -557,8 +557,8 @@ namespace Lucene.Net.Analysis.Util
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => buffer.Length >= limit);
-                    Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
+                    Debugging.Assert(buffer.Length >= limit);
+                    Debugging.Assert(offset <= 0 && offset <= buffer.Length);
                 }
 
                 for (int i = offset; i < limit;)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
index 49d2d81..a840759 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
@@ -108,10 +108,10 @@ namespace Lucene.Net.Analysis.Util
             else
             {
                 // Cannot read from future (except by 1):
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < nextPos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(pos < nextPos);
 
                 // Cannot read from already freed past:
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => nextPos - pos <= count, () => "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(nextPos - pos <= count, () => "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
 
                 return buffer[GetIndex(pos)];
             }
@@ -130,7 +130,7 @@ namespace Lucene.Net.Analysis.Util
             {
                 // Wrap:
                 index += buffer.Length;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => index >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(index >= 0);
             }
             return index;
         }
@@ -139,8 +139,8 @@ namespace Lucene.Net.Analysis.Util
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => length > 0);
-                Debugging.Assert(() => InBounds(posStart), () => "posStart=" + posStart + " length=" + length);
+                Debugging.Assert(length > 0);
+                Debugging.Assert(InBounds(posStart), () => "posStart=" + posStart + " length=" + length);
             }
             //System.out.println("    buffer.Get posStart=" + posStart + " len=" + length);
 
@@ -171,14 +171,14 @@ namespace Lucene.Net.Analysis.Util
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => pos >= 0);
-                Debugging.Assert(() => pos <= nextPos);
+                Debugging.Assert(pos >= 0);
+                Debugging.Assert(pos <= nextPos);
             }
             int newCount = nextPos - pos;
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => newCount <= count, () => "newCount=" + newCount + " count=" + count);
-                Debugging.Assert(() => newCount <= buffer.Length, () => "newCount=" + newCount + " buf.length=" + buffer.Length);
+                Debugging.Assert(newCount <= count, () => "newCount=" + newCount + " count=" + count);
+                Debugging.Assert(newCount <= buffer.Length, () => "newCount=" + newCount + " buf.length=" + buffer.Length);
             }
             count = newCount;
         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
index 39c6594..34ef795 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
@@ -184,7 +184,7 @@ namespace Lucene.Net.Analysis.Util
         /// commons-io's readFully, but without bugs if offset != 0 </summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
index d4eb3e7..a6f0ebc 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
@@ -117,7 +117,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int Delete(char[] s, int pos, int len)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < len);
+            if (Debugging.AssertsEnabled) Debugging.Assert(pos < len);
             if (pos < len - 1) // don't arraycopy if asked to delete last character
             {
                 Array.Copy(s, pos + 1, s, pos, len - pos - 1);
@@ -135,7 +135,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int DeleteN(char[] s, int pos, int len, int nChars)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos + nChars <= len);
+            if (Debugging.AssertsEnabled) Debugging.Assert(pos + nChars <= len);
             if (pos + nChars < len) // don't arraycopy if asked to delete the last characters
             {
                 Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
index fcd4bb0..49ff4a3 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
@@ -128,7 +128,7 @@ namespace Lucene.Net.Analysis.Icu
                 bool hasRemainingChars = CharacterUtils.GetInstance(LuceneVersion.LUCENE_CURRENT).Fill(tmpBuffer, m_input);
 #pragma warning restore 612, 618
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => tmpBuffer.Offset == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(tmpBuffer.Offset == 0);
                 inputBuffer.Append(tmpBuffer.Buffer, 0, tmpBuffer.Length);
 
                 if (hasRemainingChars == false)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
index 9eb4d51..1afbfc1 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
@@ -194,7 +194,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
         /// <summary>commons-io's readFully, but without bugs if offset != 0</summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
index 8629acd..823e8a6 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public virtual void Inform(IResourceLoader loader)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => tailored != null, () => "init must be called first!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(tailored != null, () => "init must be called first!");
             if (tailored.Count == 0)
             {
                 config = new DefaultICUTokenizerConfig(cjkAsWords, myanmarAsWords);
@@ -162,7 +162,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => config != null, () => "inform must be called first!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(config != null, () => "inform must be called first!");
             return new ICUTokenizer(factory, input, config);
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
index 354c377..bab5b66 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
         {
             if (useCache && ch >= 0x3040 && ch <= cacheCeiling)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => ch != FST.END_LABEL);
+                if (Debugging.AssertsEnabled) Debugging.Assert(ch != FST.END_LABEL);
                 FST.Arc<long?> result = rootCache[ch - 0x3040];
                 if (result == null)
                 {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
index 617f748..0570a17 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
@@ -91,8 +91,8 @@ namespace Lucene.Net.Analysis.Ja
 
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => !bestPathMap.ContainsKey(fromNodeID));
-                    Debugging.Assert(() => !bestPathMap.Values.Contains(toNodeID));
+                    Debugging.Assert(!bestPathMap.ContainsKey(fromNodeID));
+                    Debugging.Assert(!bestPathMap.Values.Contains(toNodeID));
                 }
                 bestPathMap[fromNodeID] = toNodeID;
                 pos = backPos;
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
index fb899c7..ac781db 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
@@ -133,7 +133,7 @@ namespace Lucene.Net.Analysis.Ja
 
             // Make katakana dakuten map from hiragana map
             char codePointDifference = (char)('\u30ab' - '\u304b'); // カ - か
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => h2d.Length == k2d.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(h2d.Length == k2d.Length);
             for (int i = 0; i < k2d.Length; i++)
             {
                 k2d[i] = (char)(h2d[i] + codePointDifference);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
index 8210652..01295b5 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis.Ja
             int leftID = dict.GetLeftId(wordID);
             int leastCost = int.MaxValue;
             int leastIDX = -1;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => fromPosData.count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(fromPosData.count > 0);
             for (int idx = 0; idx < fromPosData.count; idx++)
             {
                 // Cost is path cost so far, plus word cost (added at
@@ -356,7 +356,7 @@ namespace Lucene.Net.Analysis.Ja
             }
 
             //positions.get(endPos).add(leastCost, dict.getRightId(wordID), fromPosData.pos, leastIDX, wordID, type);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftID == dict.GetRightId(wordID));
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftID == dict.GetRightId(wordID));
             positions.Get(endPos).Add(leastCost, leftID, fromPosData.pos, leastIDX, wordID, type);
         }
 
@@ -387,7 +387,7 @@ namespace Lucene.Net.Analysis.Ja
             int position = token.Position;
             int length = token.Length;
             ClearAttributes();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => length > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(length > 0);
             //System.out.println("off=" + token.getOffset() + " len=" + length + " vs " + token.getSurfaceForm().length);
             termAtt.CopyBuffer(token.SurfaceForm, token.Offset, length);
             offsetAtt.SetOffset(CorrectOffset(position), CorrectOffset(position + length));
@@ -402,7 +402,7 @@ namespace Lucene.Net.Analysis.Ja
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => token.Position > lastTokenPos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(token.Position > lastTokenPos);
                 posIncAtt.PositionIncrement = 1;
                 posLengthAtt.PositionLength = 1;
             }
@@ -511,7 +511,7 @@ namespace Lucene.Net.Analysis.Ja
                     }
 
                     // We will always have at least one live path:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => leastIDX != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(leastIDX != -1);
 
                     // Second pass: prune all but the best path:
                     for (int pos2 = pos; pos2 < positions.GetNextPos(); pos2++)
@@ -544,7 +544,7 @@ namespace Lucene.Net.Analysis.Ja
                     if (pos != leastPosData.pos)
                     {
                         // We jumped into a future position:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < leastPosData.pos);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(pos < leastPosData.pos);
                         pos = leastPosData.pos;
                     }
 
@@ -913,10 +913,10 @@ namespace Lucene.Net.Analysis.Ja
             {
                 //System.out.println("BT: back pos=" + pos + " bestIDX=" + bestIDX);
                 Position posData = positions.Get(pos);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => bestIDX < posData.count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(bestIDX < posData.count);
 
                 int backPos = posData.backPos[bestIDX];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => backPos >= lastBackTracePos, () => "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
+                if (Debugging.AssertsEnabled) Debugging.Assert(backPos >= lastBackTracePos, () => "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
                 int length = pos - backPos;
                 JapaneseTokenizerType backType = posData.backType[bestIDX];
                 int backID = posData.backID[bestIDX];
@@ -989,7 +989,7 @@ namespace Lucene.Net.Analysis.Ja
                         if (leastIDX != -1 && leastCost <= maxCost && posData.backPos[leastIDX] != backPos)
                         {
                             // We should have pruned the altToken from the graph:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => posData.backPos[leastIDX] != backPos);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(posData.backPos[leastIDX] != backPos);
 
                             // Save the current compound token, to output when
                             // this alternate path joins back:
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Analysis.Ja
                 }
 
                 int offset = backPos - lastBackTracePos;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => offset >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(offset >= 0);
 
                 if (altToken != null && altToken.Position >= backPos)
                 {
@@ -1035,7 +1035,7 @@ namespace Lucene.Net.Analysis.Ja
                     // The pruning we did when we created the altToken
                     // ensures that the back trace will align back with
                     // the start of the altToken:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => altToken.Position == backPos, () => altToken.Position + " vs " + backPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(altToken.Position == backPos, () => altToken.Position + " vs " + backPos);
 
                     // NOTE: not quite right: the compound token may
                     // have had all punctuation back traced so far, but
@@ -1060,7 +1060,7 @@ namespace Lucene.Net.Analysis.Ja
                         {
                             Console.WriteLine("    discard all-punctuation altToken=" + altToken);
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => discardPunctuation);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(discardPunctuation);
                     }
                     altToken = null;
                 }
@@ -1355,7 +1355,7 @@ namespace Lucene.Net.Analysis.Ja
         {
             count = 0;
             // forwardCount naturally resets after it runs:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => forwardCount == 0, () => "pos=" + pos + " forwardCount=" + forwardCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(forwardCount == 0, () => "pos=" + pos + " forwardCount=" + forwardCount);
         }
     }
 
@@ -1432,13 +1432,13 @@ namespace Lucene.Net.Analysis.Ja
                     nextWrite = 0;
                 }
                 // Should have already been reset:
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => positions[nextWrite].count == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(positions[nextWrite].count == 0);
                 positions[nextWrite++].pos = nextPos++;
                 count++;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => InBounds(pos));
+            if (Debugging.AssertsEnabled) Debugging.Assert(InBounds(pos));
             int index = GetIndex(pos);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => positions[index].pos == pos);
+            if (Debugging.AssertsEnabled) Debugging.Assert(positions[index].pos == pos);
             return positions[index];
         }
 
@@ -1468,8 +1468,8 @@ namespace Lucene.Net.Analysis.Ja
             int toFree = count - (nextPos - pos);
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => toFree >= 0);
-                Debugging.Assert(() => toFree <= count);
+                Debugging.Assert(toFree >= 0);
+                Debugging.Assert(toFree <= count);
             }
             int index = nextWrite - count;
             if (index < 0)
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
index 7df6295..ef9a11c 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             for (int i = 4; i < 8; i++)
             {
                 string part = entry[i];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => part.Length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(part.Length > 0);
                 if (!"*".Equals(part, StringComparison.Ordinal))
                 {
                     if (sb.Length > 0)
@@ -120,8 +120,8 @@ namespace Lucene.Net.Analysis.Ja.Util
 
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => leftId == rightId);
-                Debugging.Assert(() => leftId < 4096); // there are still unused bits
+                Debugging.Assert(leftId == rightId);
+                Debugging.Assert(leftId < 4096); // there are still unused bits
             }
                                          // add pos mapping
             int toFill = 1 + leftId - posDict.Count;
@@ -131,7 +131,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
 
             string existing = posDict[leftId];
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
+            if (Debugging.AssertsEnabled) Debugging.Assert(existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
             posDict[leftId] = fullPOSData;
 
             m_buffer.PutInt16((short)(leftId << 3 | flags));
@@ -139,7 +139,7 @@ namespace Lucene.Net.Analysis.Ja.Util
 
             if ((flags & BinaryDictionary.HAS_BASEFORM) != 0)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => baseForm.Length < 16);
+                if (Debugging.AssertsEnabled) Debugging.Assert(baseForm.Length < 16);
                 int shared = SharedPrefix(entry[0], baseForm);
                 int suffix = baseForm.Length - shared;
                 m_buffer.Put((byte)(shared << 4 | suffix));
@@ -240,11 +240,11 @@ namespace Lucene.Net.Analysis.Ja.Util
 
         public virtual void AddMapping(int sourceId, int wordId)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => wordId > lastWordId, () => "words out of order: " + wordId + " vs lastID: " + lastWordId);
+            if (Debugging.AssertsEnabled) Debugging.Assert(wordId > lastWordId, () => "words out of order: " + wordId + " vs lastID: " + lastWordId);
 
             if (sourceId > lastSourceId)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId > lastSourceId, () => "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
+                if (Debugging.AssertsEnabled) Debugging.Assert(sourceId > lastSourceId, () => "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
                 targetMapOffsets = ArrayUtil.Grow(targetMapOffsets, sourceId + 1);
                 for (int i = lastSourceId + 1; i <= sourceId; i++)
                 {
@@ -253,7 +253,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId == lastSourceId);
+                if (Debugging.AssertsEnabled) Debugging.Assert(sourceId == lastSourceId);
             }
 
             targetMap = ArrayUtil.Grow(targetMap, targetMapEndOffset + 1);
@@ -308,7 +308,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 for (int ofs = 0; ofs < targetMapEndOffset; ofs++)
                 {
                     int val = targetMap[ofs], delta = val - prev;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(delta >= 0);
                     if (ofs == targetMapOffsets[sourceId])
                     {
                         @out.WriteVInt32((delta << 1) | 0x01);
@@ -320,7 +320,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     }
                     prev += delta;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sourceId == numSourceIds, () => "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
+                if (Debugging.AssertsEnabled) Debugging.Assert(sourceId == numSourceIds, () => "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
             }
         }
 
@@ -344,7 +344,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     else
                     {
                         string[] data = CSVUtil.Parse(s);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => data.Length == 3, () => "malformed pos/inflection: " + s);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(data.Length == 3, () => "malformed pos/inflection: " + s);
                         @out.WriteString(data[0]);
                         @out.WriteString(data[1]);
                         @out.WriteString(data[2]);
@@ -373,7 +373,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     @out.WriteByte(m_buffer.Get());
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_buffer.Remaining == 0L);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_buffer.Remaining == 0L);
             }
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
index 3e66621..1d7d8e3 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
@@ -41,12 +41,12 @@ namespace Lucene.Net.Analysis.Ja.Util
                 string line = streamReader.ReadLine();
                 string[] dimensions = whiteSpaceRegex.Split(line).TrimEnd();
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => dimensions.Length == 2);
+                if (Debugging.AssertsEnabled) Debugging.Assert(dimensions.Length == 2);
 
                 int forwardSize = int.Parse(dimensions[0], CultureInfo.InvariantCulture);
                 int backwardSize = int.Parse(dimensions[1], CultureInfo.InvariantCulture);
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => forwardSize > 0 && backwardSize > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(forwardSize > 0 && backwardSize > 0);
 
                 ConnectionCostsWriter costs = new ConnectionCostsWriter(forwardSize, backwardSize);
 
@@ -54,7 +54,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 {
                     string[] fields = whiteSpaceRegex.Split(line).TrimEnd();
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == 3);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(fields.Length == 3);
 
                     int forwardId = int.Parse(fields[0], CultureInfo.InvariantCulture);
                     int backwardId = int.Parse(fields[1], CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
index e49253e..4b5fdb4 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
@@ -63,10 +63,10 @@ namespace Lucene.Net.Analysis.Ja.Util
                 @out.WriteVInt32(forwardSize);
                 @out.WriteVInt32(backwardSize);
                 int last = 0;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => costs.Length == backwardSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(costs.Length == backwardSize);
                 foreach (short[] a in costs)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => a.Length == forwardSize);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(a.Length == forwardSize);
                     for (int i = 0; i < a.Length; i++)
                     {
                         int delta = (int)a[i] - last;
diff --git a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
index 641a400..0191323 100644
--- a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
+++ b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
@@ -85,7 +85,7 @@ namespace Lucene.Net.Analysis.Phonetic
 
             if (matcher.Success)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null && encoded != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != null && encoded != null);
                 RestoreState(state);
 
                 int start = matcher.Index;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
index d7ea253..257c662 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
@@ -42,7 +42,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Utils
                                IList<TokenFilterFactory> tokenFilterFactories)
         {
             this.charFilterFactories = charFilterFactories;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => null != tokenizerFactory);
+            if (Debugging.AssertsEnabled) Debugging.Assert(null != tokenizerFactory);
             this.tokenizerFactory = tokenizerFactory;
             this.tokenFilterFactories = tokenFilterFactories;
         }
diff --git a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
index 633599f..a83a695 100644
--- a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
+++ b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
@@ -242,7 +242,7 @@ namespace Lucene.Net.Benchmarks.Quality
                     }
                 }
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0, () => "Fishy: no \"good\" queries!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(m > 0, () => "Fishy: no \"good\" queries!");
             // take average: times go by all queries, other measures go by "good" queries only.
             avg.searchTime /= stats.Length;
             avg.docNamesExtractTime /= stats.Length;
diff --git a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
index 4f51d9a..a973cf0 100644
--- a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
+++ b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
@@ -73,7 +73,7 @@ namespace Lucene.Net.Benchmarks.Quality.Trec
                     st.MoveNext();
                     bool relevant = !zero.Equals(st.Current, StringComparison.Ordinal);
                     // LUCENENET: don't call st.NextToken() unless the condition fails.
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => st.RemainingTokens == 0, () => "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(st.RemainingTokens == 0, () => "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
                     if (relevant)
                     { // only keep relevant docs
                         if (curr == null || !curr.queryID.Equals(queryID, StringComparison.Ordinal))
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
index d9c8ccf..f5e1f6c 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
@@ -127,7 +127,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 {
                     int field = input.ReadVInt32();
                     long numTerms = input.ReadVInt64();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(numTerms >= 0);
                     long termsStartPointer = input.ReadVInt64();
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : input.ReadVInt64();
@@ -234,7 +234,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
         public override Terms GetTerms(string field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
 
             FieldReader result;
             fields.TryGetValue(field, out result);
@@ -258,7 +258,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldReader(BlockTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int longsSize)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numTerms > 0);
 
                 this.outerInstance = outerInstance;
 
@@ -449,7 +449,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                         // Block must exist since, at least, the indexed term
                         // is in the block:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(result);
 
                         indexIsCurrent = true;
                         didIndexNext = false;
@@ -537,7 +537,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 // Target's prefix is before the common prefix
                                 // of this block, so we position to start of
                                 // block and return NOT_FOUND:
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TermBlockOrd == 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(state.TermBlockOrd == 0);
 
                                 int suffix = termSuffixesReader.ReadVInt32();
                                 term.Length = termBlockPrefix + suffix;
@@ -642,7 +642,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // cross another index term (besides the first
                         // one) while we are scanning:
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(indexIsCurrent);
 
                         if (!NextBlock())
                         {
@@ -665,7 +665,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // works properly:
                     if (seekPending)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!indexIsCurrent);
                         input.Seek(state.BlockFilePointer);
                         int pendingSeekCount = state.TermBlockOrd;
                         bool result = NextBlock();
@@ -675,12 +675,12 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // Block must exist since seek(TermState) was called w/ a
                         // TermState previously returned by this enum when positioned
                         // on a real term:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(result);
 
                         while (state.TermBlockOrd < pendingSeekCount)
                         {
                             BytesRef nextResult = _next();
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextResult != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(nextResult != null);
                         }
                         seekPending = false;
                         state.Ord = savOrd;
@@ -771,8 +771,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                     //System.out.println("BTR.seekExact termState target=" + target.utf8ToString() + " " + target + " this=" + this);
                     if (Debugging.AssertsEnabled)
                     {
-                        Debugging.Assert(() => otherState != null && otherState is BlockTermState);
-                        Debugging.Assert(() => !doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
+                        Debugging.Assert(otherState != null && otherState is BlockTermState);
+                        Debugging.Assert(!doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
                     }
                     state.CopyFrom(otherState);
                     seekPending = true;
@@ -797,7 +797,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         throw new InvalidOperationException("terms index was not loaded");
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < outerInstance.numTerms);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ord < outerInstance.numTerms);
 
                     // TODO: if ord is in same terms block and
                     // after current ord, we should avoid this seek just
@@ -806,7 +806,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     bool result = NextBlock();
 
                     // Block must exist since ord < numTerms:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(result);
 
                     indexIsCurrent = true;
                     didIndexNext = false;
@@ -814,7 +814,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     seekPending = false;
 
                     state.Ord = indexEnum.Ord - 1;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state.Ord >= -1, () => "Ord=" + state.Ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state.Ord >= -1, () => "Ord=" + state.Ord);
                     term.CopyBytes(indexEnum.Term);
 
                     // Now, scan:
@@ -822,9 +822,9 @@ namespace Lucene.Net.Codecs.BlockTerms
                     while (left > 0)
                     {
                         BytesRef term = _next();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(term != null);
                         left--;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexIsCurrent);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(indexIsCurrent);
                     }
                 }
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
index 18eb752..87ecb55 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldMetaData(FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int int64sSize)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numTerms > 0);
 
                 FieldInfo = fieldInfo;
                 TermsStartPointer = termsStartPointer;
@@ -123,7 +123,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         public override TermsConsumer AddField(FieldInfo field)
         {
             //System.out.println("\nBTW.addField seg=" + segment + " field=" + field.name);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             TermsIndexWriterBase.FieldWriter fieldIndexWriter = termsIndexWriter.AddField(field, m_output.GetFilePointer());
             return new TermsWriter(this, fieldIndexWriter, field, postingsWriter);
@@ -235,7 +235,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq > 0);
                 //System.out.println("BTW: finishTerm term=" + fieldInfo.name + ":" + text.utf8ToString() + " " + text + " seg=" + segment + " df=" + stats.docFreq);
 
                 bool isIndexTerm = fieldIndexWriter.CheckIndexTerm(text, stats);
@@ -304,8 +304,8 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => term1.Offset == 0);
-                    Debugging.Assert(() => term2.Offset == 0);
+                    Debugging.Assert(term1.Offset == 0);
+                    Debugging.Assert(term2.Offset == 0);
                 }
                 int pos1 = 0;
                 int pos1End = pos1 + Math.Min(term1.Length, term2.Length);
@@ -362,7 +362,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 for (int termCount = 0; termCount < pendingCount; termCount++)
                 {
                     BlockTermState state = pendingTerms[termCount].State;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != null);
                     bytesWriter.WriteVInt32(state.DocFreq);
                     if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                     {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
index ca21abb..2d62b7b 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         {
             this.termComp = termComp;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexDivisor == -1 || indexDivisor > 0);
 
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, FixedGapTermsIndexWriter.TERMS_INDEX_EXTENSION), context);
 
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // In case terms index gets loaded, later, on demand
                     totalIndexInterval = indexInterval * indexDivisor;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => totalIndexInterval > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(totalIndexInterval > 0);
 
                 SeekDir(input, dirOffset);
 
@@ -190,7 +190,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int lo = 0;          // binary search
                 int hi = fieldIndex.numIndexTerms - 1;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.totalIndexInterval > 0, () => "totalIndexInterval=" + outerInstance.totalIndexInterval);
+                if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.totalIndexInterval > 0, () => "totalIndexInterval=" + outerInstance.totalIndexInterval);
 
                 while (hi >= lo)
                 {
@@ -211,7 +211,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     }
                     else
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => mid >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(mid >= 0);
                         ord = mid * outerInstance.totalIndexInterval;
                         return fieldIndex.termsStart + fieldIndex.termsDictOffsets.Get(mid);
                     }
@@ -219,7 +219,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                 if (hi < 0)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hi == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(hi == -1);
                     hi = 0;
                 }
 
@@ -252,7 +252,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int idx = (int)(ord / outerInstance.totalIndexInterval);
                 // caller must ensure ord is in bounds
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => idx < fieldIndex.numIndexTerms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(idx < fieldIndex.numIndexTerms);
                 long offset = fieldIndex.termOffsets.Get(idx);
                 int length = (int)(fieldIndex.termOffsets.Get(1 + idx) - offset);
                 outerInstance.termBytesReader.FillSlice(term, fieldIndex.termBytesStart + offset, length);
@@ -328,11 +328,11 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // -1 is passed to mean "don't load term index", but
                     // if we are then later loaded it's overwritten with
                     // a real value
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.outerInstance.indexDivisor > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.outerInstance.indexDivisor > 0);
 
                     this.numIndexTerms = 1 + (numIndexTerms - 1) / outerInstance.outerInstance.indexDivisor;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => this.numIndexTerms > 0, () => "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(this.numIndexTerms > 0, () => "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
 
                     if (outerInstance.outerInstance.indexDivisor == 1)
                     {
@@ -345,11 +345,11 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                             // records offsets into main terms dict file
                             termsDictOffsets = PackedInt32s.GetReader(clone);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsDictOffsets.Count == numIndexTerms);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(termsDictOffsets.Count == numIndexTerms);
 
                             // records offsets into byte[] term data
                             termOffsets = PackedInt32s.GetReader(clone);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termOffsets.Count == 1 + numIndexTerms);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(termOffsets.Count == 1 + numIndexTerms);
                         }
                         finally
                         {
@@ -400,8 +400,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 clone.Seek(indexStart + termOffset);
                                 if (Debugging.AssertsEnabled)
                                 {
-                                    Debugging.Assert(() => indexStart + termOffset < clone.Length, () => "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
-                                    Debugging.Assert(() => indexStart + termOffset + numTermBytes < clone.Length);
+                                    Debugging.Assert(indexStart + termOffset < clone.Length, () => "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
+                                    Debugging.Assert(indexStart + termOffset + numTermBytes < clone.Length);
                                 }
 
                                 outerInstance.outerInstance.termBytes.Copy(clone, numTermBytes);
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
index ac25b8d..430365a 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
@@ -187,7 +187,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 lastTermsPointer = termsFilePointer;
 
                 // save term length (in bytes)
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => indexedTermLength <= short.MaxValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(indexedTermLength <= short.MaxValue);
                 termLengths[numIndexTerms] = (short)indexedTermLength;
                 totTermLength += indexedTermLength;
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
index d6caa49..9bb67b5 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
@@ -55,7 +55,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, VariableGapTermsIndexWriter.TERMS_INDEX_EXTENSION), new IOContext(context, true));
             //this.segment = segment; // LUCENENET: Not used
             bool success = false;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexDivisor == -1 || indexDivisor > 0);
 
             try
             {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
index db5c9a5..80fa33b 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
@@ -292,7 +292,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 if (text.Length == 0)
                 {
                     // We already added empty string in ctor
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => termsFilePointer == startTermsFilePointer);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(termsFilePointer == startTermsFilePointer);
                     return;
                 }
                 int lengthSave = text.Length;
diff --git a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
index b2aaf1d..9f4cc05 100644
--- a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
@@ -380,7 +380,7 @@ namespace Lucene.Net.Codecs.Bloom
                 var bloomFilter = outerInstance._bloomFilterFactory.GetSetForField(_state, field);
                 if (bloomFilter != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (_bloomFilters.ContainsKey(field) == false));
+                    if (Debugging.AssertsEnabled) Debugging.Assert((_bloomFilters.ContainsKey(field) == false));
 
                     _bloomFilters.Add(field, bloomFilter);
                     return new WrappedTermsConsumer(_delegateFieldsConsumer.AddField(field), bloomFilter);
diff --git a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
index 76c007a..c3cb2ce 100644
--- a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
+++ b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
@@ -228,7 +228,7 @@ namespace Lucene.Net.Codecs.Bloom
 
         private ContainsResult MayContainValue(int positiveHash)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => (positiveHash >= 0));
+            if (Debugging.AssertsEnabled) Debugging.Assert((positiveHash >= 0));
 
             // Bloom sizes are always base 2 and so can be ANDed for a fast modulo
             var pos = positiveHash & _bloomSize;
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
index f0ce63c..d201869 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
@@ -109,7 +109,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             internal virtual void Seek(long fp, int upto)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < blockSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(upto < blockSize);
                 if (seekPending || fp != lastBlockFP)
                 {
                     pendingFP = fp;
@@ -173,7 +173,7 @@ namespace Lucene.Net.Codecs.IntBlock
                         fp += indexIn.ReadVInt64();
                     }
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto < outerInstance.m_blockSize);
+                if (Debugging.AssertsEnabled) Debugging.Assert(upto < outerInstance.m_blockSize);
             }
 
             public override void Seek(Int32IndexInput.Reader other)
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
index 869b93a..d6bc3d4 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= lastUpto);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
index 3c90d8c..0a65f5a 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
@@ -118,7 +118,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 // TODO: should we do this in real-time, not lazy?
                 pendingFP = fp;
                 pendingUpto = upto;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingUpto >= 0, () => "pendingUpto=" + pendingUpto);
+                if (Debugging.AssertsEnabled) Debugging.Assert(pendingUpto >= 0, () => "pendingUpto=" + pendingUpto);
                 seekPending = true;
             }
 
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
index db3af9d..1bc8a78 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override void Write(DataOutput indexOut, bool absolute)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(upto >= 0);
                 if (absolute)
                 {
                     indexOut.WriteVInt32(upto);
@@ -116,7 +116,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= lastUpto);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
@@ -136,7 +136,7 @@ namespace Lucene.Net.Codecs.IntBlock
             hitExcDuringWrite = true;
             upto -= Add(v) - 1;
             hitExcDuringWrite = false;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(upto >= 0);
         }
 
         protected override void Dispose(bool disposing)
@@ -152,7 +152,7 @@ namespace Lucene.Net.Codecs.IntBlock
                     while (upto > stuffed)
                     {
                         upto -= Add(0) - 1;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => upto >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(upto >= 0);
                         stuffed += 1;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
index 2d92f3f..ecd18e8 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
@@ -372,7 +372,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                     else
                     { 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(false);
                         return false;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
index 330237a..8df0270 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
@@ -552,7 +552,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length % 8 == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(length % 8 == 0);
                         var bits = new long[(int)length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
index 63c9a80..be7e794 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
@@ -589,7 +589,7 @@ namespace Lucene.Net.Codecs.Memory
 
                             upto++;
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == docFreq);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(upto == docFreq);
                         ent = new HighFreqTerm(docs, freqs, positions, payloads, totalTermFreq);
                     }
 
@@ -625,7 +625,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                 }
                 this.skipOffsets[numTerms] = skipOffset;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => skipOffset == skipCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(skipOffset == skipCount);
             }
 
             /// <summary>Returns approximate RAM bytes used. </summary>
@@ -738,7 +738,7 @@ namespace Lucene.Net.Codecs.Memory
 
             private void FinishSkips()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == terms.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == terms.Length);
                 int lastTermOffset = termOffsets[count - 1];
                 int lastTermLength = termOffsets[count] - lastTermOffset;
 
@@ -972,7 +972,7 @@ namespace Lucene.Net.Codecs.Memory
                 {
                     termOrd = (int) ((OrdTermState) state).Ord;
                     SetTerm();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Equals(scratch));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(term.Equals(scratch));
                 }
 
                 public override BytesRef Term => scratch;
@@ -1207,15 +1207,15 @@ namespace Lucene.Net.Codecs.Memory
                                 while (label > states[i].transitionMax)
                                 {
                                     states[i].transitionUpto++;
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => states[i].transitionUpto < states[i].transitions.Length);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(states[i].transitionUpto < states[i].transitions.Length);
                                     states[i].transitionMin = states[i].transitions[states[i].transitionUpto].Min;
                                     states[i].transitionMax = states[i].transitions[states[i].transitionUpto].Max;
                                     if (Debugging.AssertsEnabled)
                                     {
-                                        Debugging.Assert(() => states[i].transitionMin >= 0);
-                                        Debugging.Assert(() => states[i].transitionMin <= 255);
-                                        Debugging.Assert(() => states[i].transitionMax >= 0);
-                                        Debugging.Assert(() => states[i].transitionMax <= 255);
+                                        Debugging.Assert(states[i].transitionMin >= 0);
+                                        Debugging.Assert(states[i].transitionMin <= 255);
+                                        Debugging.Assert(states[i].transitionMax >= 0);
+                                        Debugging.Assert(states[i].transitionMax <= 255);
                                     }
                                 }
 
@@ -1257,7 +1257,7 @@ namespace Lucene.Net.Codecs.Memory
                                         //   System.out.println("  no match; already beyond; return termOrd=" + termOrd);
                                         // }
                                         stateUpto -= skipUpto;
-                                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto >= 0);
+                                        if (Debugging.AssertsEnabled) Debugging.Assert(stateUpto >= 0);
                                         return;
                                     }
                                     else if (label == (outerInstance.termBytes[termOffset_i + i] & 0xFF))
@@ -1272,7 +1272,7 @@ namespace Lucene.Net.Codecs.Memory
                                             int nextState = runAutomaton.Step(states[stateUpto].state, label);
 
                                             // Automaton is required to accept startTerm:
-                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextState != -1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(nextState != -1);
 
                                             stateUpto++;
                                             states[stateUpto].changeOrd = outerInstance.skips[skipOffset + skipUpto++];
@@ -1303,12 +1303,12 @@ namespace Lucene.Net.Codecs.Memory
                                             while (termOrd < outerInstance.terms.Length &&
                                                    outerInstance.Compare(termOrd, startTerm) <= 0)
                                             {
-                                                if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd == startTermOrd ||
+                                                if (Debugging.AssertsEnabled) Debugging.Assert(termOrd == startTermOrd ||
                                                              outerInstance.skipOffsets[termOrd] ==
                                                              outerInstance.skipOffsets[termOrd + 1]);
                                                 termOrd++;
                                             }
-                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd - startTermOrd < outerInstance.minSkipCount);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(termOrd - startTermOrd < outerInstance.minSkipCount);
                                             termOrd--;
                                             stateUpto -= skipUpto;
                                             // if (DEBUG) {
@@ -1389,7 +1389,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (termOrd == 0 && outerInstance.termOffsets[1] == 0)
                     {
                         // Special-case empty string:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(stateUpto == 0);
                         // if (DEBUG) {
                         //   System.out.println("  visit empty string");
                         // }
@@ -1438,9 +1438,9 @@ namespace Lucene.Net.Codecs.Memory
                         //   System.out.println("  term=" + new BytesRef(termBytes, termOffset, termLength).utf8ToString() + " skips=" + Arrays.toString(skips));
                         // }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => termOrd < state.changeOrd);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(termOrd < state.changeOrd);
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => stateUpto <= termLength, () => "term.length=" + termLength + "; stateUpto=" + stateUpto);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(stateUpto <= termLength, () => "term.length=" + termLength + "; stateUpto=" + stateUpto);
                         int label = outerInstance.termBytes[termOffset + stateUpto] & 0xFF;
 
                         while (label > state.transitionMax)
@@ -1459,7 +1459,7 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 else
                                 {
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state.changeOrd > termOrd);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(state.changeOrd > termOrd);
                                     // if (DEBUG) {
                                     //   System.out.println("  jumpend " + (state.changeOrd - termOrd));
                                     // }
@@ -1470,16 +1470,16 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 goto nextTermContinue;
                             }
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.transitionUpto < state.transitions.Length,
+                            if (Debugging.AssertsEnabled) Debugging.Assert(state.transitionUpto < state.transitions.Length,
                                 () => " state.transitionUpto=" + state.transitionUpto + " vs " + state.transitions.Length);
                             state.transitionMin = state.transitions[state.transitionUpto].Min;
                             state.transitionMax = state.transitions[state.transitionUpto].Max;
                             if (Debugging.AssertsEnabled)
                             {
-                                Debugging.Assert(() => state.transitionMin >= 0);
-                                Debugging.Assert(() => state.transitionMin <= 255);
-                                Debugging.Assert(() => state.transitionMax >= 0);
-                                Debugging.Assert(() => state.transitionMax <= 255);
+                                Debugging.Assert(state.transitionMin >= 0);
+                                Debugging.Assert(state.transitionMin <= 255);
+                                Debugging.Assert(state.transitionMax >= 0);
+                                Debugging.Assert(state.transitionMax <= 255);
                             }
                         }
 
@@ -1609,7 +1609,7 @@ namespace Lucene.Net.Codecs.Memory
                             if (compiledAutomaton.CommonSuffixRef != null)
                             {
                                 //System.out.println("suffix " + compiledAutomaton.commonSuffixRef.utf8ToString());
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(compiledAutomaton.CommonSuffixRef.Offset == 0);
                                 if (termLength < compiledAutomaton.CommonSuffixRef.Length)
                                 {
                                     termOrd++;
@@ -2008,7 +2008,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                         return postings[upto];
                     }
                 }
@@ -2017,7 +2017,7 @@ namespace Lucene.Net.Codecs.Memory
                     while (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                         if (liveDocs.Get(postings[upto]))
                         {
                             return postings[upto];
@@ -2192,7 +2192,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => skipPositions > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(skipPositions > 0);
                 skipPositions--;
 
                 int pos = postings[upto++];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
index 6d79270..c34bd4c 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
@@ -166,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -218,7 +218,7 @@ namespace Lucene.Net.Codecs.Memory
                 this.longsSize = longsSize;
                 this.index = index;
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (numTerms & (~0xffffffffL)) == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert((numTerms & (~0xffffffffL)) == 0);
                 int numBlocks = (int)(numTerms + INTERVAL - 1) / INTERVAL;
                 this.numSkipInfo = longsSize + 3;
                 this.skipInfo = new long[numBlocks * numSkipInfo];
@@ -500,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         var status = SeekCeil(term);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
+                        if (Debugging.AssertsEnabled) Debugging.Assert(status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -631,7 +631,7 @@ namespace Lucene.Net.Codecs.Memory
                 internal override void DecodeStats()
                 {
                     var arc = TopFrame().arc;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.NextFinalOutput == fstOutputs.NoOutput);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(arc.NextFinalOutput == fstOutputs.NoOutput);
                     ord = arc.Output.Value;
                     base.DecodeStats();
                 }
@@ -699,7 +699,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
+                        if (Debugging.AssertsEnabled) Debugging.Assert(IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
@@ -837,7 +837,7 @@ namespace Lucene.Net.Codecs.Memory
                     arc.Output = fstOutputs.Add(TopFrame().arc.Output, arc.Output);
                     term = Grow(arc.Label);
                     level++;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => frame == stack[level]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(frame == stack[level]);
                 }
 
                 private Frame PopFrame()
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
index 16d2d0c..f072365 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
@@ -128,7 +128,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t1, NO_OUTPUT) || Equals(t2, NO_OUTPUT))
                 return NO_OUTPUT;
             
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(t1.longs.Length == t2.longs.Length);
 
             long[] min = t1.longs, max = t2.longs;
             int pos = 0;
@@ -183,7 +183,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(t1.longs.Length == t2.longs.Length);
 
             int pos = 0;
             long diff = 0;
@@ -220,7 +220,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(t1.longs.Length == t2.longs.Length);
 
             var pos = 0;
             var accum = new long[_longsSize];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
index e12eb5a..38d6da7 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
@@ -166,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -369,7 +369,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         SeekStatus status = SeekCeil(term);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
+                        if (Debugging.AssertsEnabled) Debugging.Assert(status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -500,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 internal override void DecodeMetaData()
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(term != null);
                     if (!decoded)
                     {
                         if (meta.bytes != null)
@@ -611,7 +611,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
+                        if (Debugging.AssertsEnabled) Debugging.Assert(IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
index 2176e99..cb6dc17 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
@@ -144,7 +144,7 @@ namespace Lucene.Net.Codecs.Memory
 
                     ++count;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
             }
 
             if (missing)
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
index 802ca19..535844f 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
@@ -675,7 +675,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length % 8 == 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(length % 8 == 0);
                         var bits = new long[(int) length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index 7fa27bf..1bf2067 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -146,7 +146,7 @@ namespace Lucene.Net.Codecs.Memory
                 public override void StartDoc(int docID, int termDocFreq)
                 {
                     int delta = docID - lastDocID;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docID == 0 || delta > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(docID == 0 || delta > 0);
                     lastDocID = docID;
                     docCount++;
 
@@ -161,7 +161,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         buffer.WriteVInt32(delta << 1);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => termDocFreq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(termDocFreq > 0);
                         buffer.WriteVInt32(termDocFreq);
                     }
 
@@ -171,12 +171,12 @@ namespace Lucene.Net.Codecs.Memory
 
                 public override void AddPosition(int pos, BytesRef payload, int startOffset, int endOffset)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null || outerInstance.field.HasPayloads);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(payload == null || outerInstance.field.HasPayloads);
 
                     //System.out.println("      addPos pos=" + pos + " payload=" + payload);
 
                     int delta = pos - lastPos;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(delta >= 0);
                     lastPos = pos;
 
                     int payloadLen = 0;
@@ -231,7 +231,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 public virtual PostingsWriter Reset()
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.GetFilePointer() == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(buffer.GetFilePointer() == 0);
                     lastDocID = 0;
                     docCount = 0;
                     lastPayloadLen = 0;
@@ -255,9 +255,9 @@ namespace Lucene.Net.Codecs.Memory
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => postingsWriter.docCount == stats.DocFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(postingsWriter.docCount == stats.DocFreq);
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer2.GetFilePointer() == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(buffer2.GetFilePointer() == 0);
 
                 buffer2.WriteVInt32(stats.DocFreq);
                 if (field.IndexOptions != IndexOptions.DOCS_ONLY)
@@ -402,7 +402,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numDocs > 0);
                 if (buffer.Length < bufferIn.Length)
                 {
                     buffer = ArrayUtil.Grow(buffer, bufferIn.Length);
@@ -446,7 +446,7 @@ namespace Lucene.Net.Codecs.Memory
                         else
                         {
                             freq = @in.ReadVInt32();
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                         }
 
                         if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
@@ -555,7 +555,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsAndPositionsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numDocs > 0);
 
                 // System.out.println("D&P reset bytes this=" + this);
                 // for(int i=bufferIn.offset;i<bufferIn.length;i++) {
@@ -606,7 +606,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         freq = @in.ReadVInt32();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                     }
 
                     if (liveDocs == null || liveDocs.Get(accum))
@@ -655,7 +655,7 @@ namespace Lucene.Net.Codecs.Memory
             public override int NextPosition()
             {
                 //System.out.println("    nextPos storePayloads=" + storePayloads + " this=" + this);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => posPending > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(posPending > 0);
                 posPending--;
                 if (!storePayloads)
                 {
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
index 8f61c25..f91fb84 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Codecs.Pulsing
             int minBlockSize, int maxBlockSize) 
             : base()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => minBlockSize > 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(minBlockSize > 1);
 
             _freqCutoff = freqCutoff;
             _minBlockSize = minBlockSize;
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
index b7568b2..d429bd6 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
@@ -122,7 +122,7 @@ namespace Lucene.Net.Codecs.Pulsing
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => WrappedTermState != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(WrappedTermState != null);
                     clone.WrappedTermState = (BlockTermState)WrappedTermState.Clone();
                     clone.Absolute = Absolute;
 
@@ -172,7 +172,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var termState2 = (PulsingTermState) termState;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => empty.Length == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(empty.Length == 0);
 
             termState2.Absolute = termState2.Absolute || absolute;
             // if we have positions, its total TF, otherwise its computed based on docFreq.
@@ -340,7 +340,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termState.PostingsSize != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termState.PostingsSize != -1);
 
                 // Must make a copy of termState's byte[] so that if
                 // app does TermsEnum.next(), this DocsEnum is not affected
@@ -482,7 +482,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsAndPositionsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termState.PostingsSize != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termState.PostingsSize != -1);
 
                 if (_postingsBytes == null)
                 {
@@ -542,7 +542,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => _posPending > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(_posPending > 0);
 
                 _posPending--;
 
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
index f1b0ec5..e01618d 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
@@ -150,7 +150,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartTerm()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(_pendingCount == 0);
         }
 
         // TODO: -- should we NOT reuse across fields?  would
@@ -175,7 +175,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartDoc(int docId, int termDocFreq)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docId >= 0, () => "Got DocID=" + docId);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docId >= 0, () => "Got DocID=" + docId);
 
             if (_pendingCount == _pending.Length)
             {
@@ -185,7 +185,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             if (_pendingCount != -1)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount < _pending.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(_pendingCount < _pending.Length);
                 _currentDoc = _pending[_pendingCount];
                 _currentDoc.docID = docId;
                 if (_indexOptions == IndexOptions.DOCS_ONLY)
@@ -267,7 +267,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var state2 = (PulsingTermState)state;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount > 0 || _pendingCount == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(_pendingCount > 0 || _pendingCount == -1);
 
             if (_pendingCount == -1)
             {
@@ -318,7 +318,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         for (var posIDX = 0; posIDX < doc.termFreq; posIDX++)
                         {
                             var pos = _pending[pendingIDX++];
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos.docID == doc.docID);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(pos.docID == doc.docID);
                             var posDelta = pos.pos - lastPos;
                             lastPos = pos.pos;
 
@@ -361,7 +361,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
                             if (payloadLength > 0)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => _storePayloads);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(_storePayloads);
                                 _buffer.WriteBytes(pos.payload.Bytes, 0, pos.payload.Length);
                             }
                         }
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         Position doc = _pending[posIdx];
                         int delta = doc.docID - lastDocId;
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => doc.termFreq != 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(doc.termFreq != 0);
 
                         if (doc.termFreq == 1)
                         {
@@ -411,7 +411,7 @@ namespace Lucene.Net.Codecs.Pulsing
             bool abs)
         {
             var _state = (PulsingTermState)state;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => empty.Length == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(empty.Length == 0);
             _absolute = _absolute || abs;
             if (_state.bytes == null)
             {
@@ -469,7 +469,7 @@ namespace Lucene.Net.Codecs.Pulsing
         /// </summary>
         private void Push()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => _pendingCount == _pending.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(_pendingCount == _pending.Length);
 
             _wrappedPostingsWriter.StartTerm();
 
@@ -487,7 +487,7 @@ namespace Lucene.Net.Codecs.Pulsing
                     }
                     else if (doc.docID != pos.docID)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => pos.docID > doc.docID);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(pos.docID > doc.docID);
                         _wrappedPostingsWriter.FinishDoc();
                         doc = pos;
                         _wrappedPostingsWriter.StartDoc(doc.docID, doc.termFreq);
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
index dad545a..b6565cf 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
@@ -263,7 +263,7 @@ namespace Lucene.Net.Codecs.Sep
         public override DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState termState,
             IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
             SepTermState termState_ = (SepTermState)termState;
             SepDocsAndPositionsEnum postingsEnum;
             if (reuse == null || !(reuse is SepDocsAndPositionsEnum))
@@ -692,7 +692,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payloadLength >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(payloadLength >= 0);
                     }
                     pendingPosCount--;
                     position = 0;
@@ -707,7 +707,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payloadLength >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(payloadLength >= 0);
                     }
                     position += (int)(((uint)code) >> 1);
                     pendingPayloadBytes += payloadLength;
@@ -719,7 +719,7 @@ namespace Lucene.Net.Codecs.Sep
                 }
 
                 pendingPosCount--;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingPosCount >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(pendingPosCount >= 0);
                 return position;
             }
 
@@ -741,7 +741,7 @@ namespace Lucene.Net.Codecs.Sep
                     return payload;
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingPayloadBytes >= payloadLength);
+                if (Debugging.AssertsEnabled) Debugging.Assert(pendingPayloadBytes >= payloadLength);
 
                 if (pendingPayloadBytes > payloadLength)
                 {
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
index e460fde..f4b2d13 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
@@ -262,10 +262,10 @@ namespace Lucene.Net.Codecs.Sep
         /// Add a new position &amp; payload. </summary>
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
 
             int delta = position - lastPosition;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
+            if (Debugging.AssertsEnabled) Debugging.Assert(delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
             lastPosition = position;
 
             if (storePayloads)
@@ -319,8 +319,8 @@ namespace Lucene.Net.Codecs.Sep
             // TODO: -- wasteful we are counting this in two places?
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => state_.DocFreq > 0);
-                Debugging.Assert(() => state_.DocFreq == df);
+                Debugging.Assert(state_.DocFreq > 0);
+                Debugging.Assert(state_.DocFreq == df);
             }
 
             state_.DocIndex = docOut.GetIndex();
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
index b7c50ef..ab7af41 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
@@ -195,7 +195,7 @@ namespace Lucene.Net.Codecs.Sep
         protected override int ReadSkipData(int level, IndexInput skipStream)
         {
             int delta;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
             if (currentFieldStoresPayloads)
             {
                 // the current field stores payloads.
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
index 2ef7094..f65b922 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
@@ -178,7 +178,7 @@ namespace Lucene.Net.Codecs.Sep
             //         current payload length equals the length at the previous
             //         skip point
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
 
             if (curStorePayloads)
             {
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
index 2123bd4..47ffc15 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
@@ -76,25 +76,25 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     break;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.FIELD), () => scratch.Utf8ToString());
+                if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.FIELD), () => scratch.Utf8ToString());
                 var fieldName = StripPrefix(SimpleTextDocValuesWriter.FIELD);
                 var field = new OneField();
                 
                 fields[fieldName] = field;
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
+                if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
 
                 var dvType = (DocValuesType)Enum.Parse(typeof(DocValuesType), StripPrefix(SimpleTextDocValuesWriter.TYPE));
-                // if (Debugging.AssertsEnabled) Debugging.Assert(() => dvType != null); // LUCENENET: Not possible for an enum to be null in .NET
+                // if (Debugging.AssertsEnabled) Debugging.Assert(dvType != null); // LUCENENET: Not possible for an enum to be null in .NET
                 if (dvType == DocValuesType.NUMERIC)
                 {
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MINVALUE),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.MINVALUE),
                         () => "got " + scratch.Utf8ToString() + " field=" + fieldName + " ext=" + ext);
                     field.MinValue = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.MINVALUE), CultureInfo.InvariantCulture);
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (1 + field.Pattern.Length + 2)*maxDoc);
@@ -102,10 +102,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.BINARY)
                 {
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength + 2)*maxDoc);
@@ -113,16 +113,16 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.SORTED || dvType == DocValuesType.SORTED_SET)
                 {
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
                     field.NumValues = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.NUMVALUES), CultureInfo.InvariantCulture);
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
                     field.OrdPattern = StripPrefix(SimpleTextDocValuesWriter.ORDPATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength)*field.NumValues +
@@ -136,7 +136,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // We should only be called from above if at least one
             // field has DVs:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(fields.Count > 0);
         }
 
         public override NumericDocValues GetNumeric(FieldInfo fieldInfo)
@@ -144,10 +144,10 @@ namespace Lucene.Net.Codecs.SimpleText
             var field = fields[fieldInfo.Name];
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => field != null);
+                Debugging.Assert(field != null);
 
                 // SegmentCoreReaders already verifies this field is valid:
-                Debugging.Assert(() => field != null, () => "field=" + fieldInfo.Name + " fields=" + fields);
+                Debugging.Assert(field != null, () => "field=" + fieldInfo.Name + " fields=" + fields);
             }
 
             var @in = (IndexInput)data.Clone();
@@ -244,7 +244,7 @@ namespace Lucene.Net.Codecs.SimpleText
         public override BinaryDocValues GetBinary(FieldInfo fieldInfo)
         {
             var field = fields[fieldInfo.Name];
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -278,7 +278,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * docId);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -335,7 +335,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * index);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -368,7 +368,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var field = fields[fieldInfo.Name];
 
             // SegmentCoreReaders already verifies this field is valid:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -437,7 +437,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
                         () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
@@ -473,7 +473,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // SegmentCoreReaders already verifies this field is
             // valid:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
 
             var input = (IndexInput) data.Clone();
             var scratch = new BytesRef();
@@ -542,7 +542,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
                         () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
index e7bc522..8ca1703 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Codecs.SimpleText
         /// </summary>
         private bool FieldSeen(string field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !_fieldsSeen.Contains(field), () => "field \"" + field + "\" was added more than once during flush");
+            if (Debugging.AssertsEnabled) Debugging.Assert(!_fieldsSeen.Contains(field), () => "field \"" + field + "\" was added more than once during flush");
             _fieldsSeen.Add(field);
             return true;
         }
@@ -78,8 +78,8 @@ namespace Lucene.Net.Codecs.SimpleText
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => FieldSeen(field.Name));
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC ||
+                Debugging.Assert(FieldSeen(field.Name));
+                Debugging.Assert(field.DocValuesType == DocValuesType.NUMERIC ||
                              field.NormType == DocValuesType.NUMERIC);
             }
             WriteFieldEntry(field, DocValuesType.NUMERIC);
@@ -121,28 +121,28 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 long value = n.GetValueOrDefault();
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => value >= minValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(value >= minValue);
 
                 var delta = (decimal)value - (decimal)minValue; // LUCENENET specific - use decimal rather than BigInteger
                 string s = delta.ToString(patternString, CultureInfo.InvariantCulture);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => s.Length == patternString.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(s.Length == patternString.Length);
                 SimpleTextUtil.Write(data, s, scratch);
                 SimpleTextUtil.WriteNewline(data);
                 SimpleTextUtil.Write(data, n == null ? "F" : "T", scratch);
                 SimpleTextUtil.WriteNewline(data);
                 numDocsWritten++;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocsWritten <= numDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numDocsWritten <= numDocs);
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numDocsWritten, () => "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
+            if (Debugging.AssertsEnabled) Debugging.Assert(numDocs == numDocsWritten, () => "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
         }
 
         public override void AddBinaryField(FieldInfo field, IEnumerable<BytesRef> values)
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => FieldSeen(field.Name));
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
+                Debugging.Assert(FieldSeen(field.Name));
+                Debugging.Assert(field.DocValuesType == DocValuesType.BINARY);
             }
 
             var maxLength = 0;
@@ -198,15 +198,15 @@ namespace Lucene.Net.Codecs.SimpleText
                 numDocsWritten++;
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numDocsWritten);
+            if (Debugging.AssertsEnabled) Debugging.Assert(numDocs == numDocsWritten);
         }
 
         public override void AddSortedField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<long?> docToOrd)
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => FieldSeen(field.Name));
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
+                Debugging.Assert(FieldSeen(field.Name));
+                Debugging.Assert(field.DocValuesType == DocValuesType.SORTED);
             }
             WriteFieldEntry(field, DocValuesType.SORTED);
 
@@ -277,10 +277,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen <= valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(valuesSeen <= valueCount);
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen == valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valuesSeen == valueCount);
 
             foreach (var ord in docToOrd)
             {
@@ -294,8 +294,8 @@ namespace Lucene.Net.Codecs.SimpleText
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => FieldSeen(field.Name));
-                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
+                Debugging.Assert(FieldSeen(field.Name));
+                Debugging.Assert(field.DocValuesType == DocValuesType.SORTED_SET);
             }
             WriteFieldEntry(field, DocValuesType.SORTED_SET);
 
@@ -387,10 +387,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen <= valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(valuesSeen <= valueCount);
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valuesSeen == valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valuesSeen == valueCount);
 
             using (var ordStream = ords.GetEnumerator())
             {
@@ -438,7 +438,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var success = false;
             try
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => _fieldsSeen.Count > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(_fieldsSeen.Count > 0);
                 // java : sheisty to do this here?
                 SimpleTextUtil.Write(data, END);
                 SimpleTextUtil.WriteNewline(data);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
index e9a68b0..a7c423a 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
@@ -57,29 +57,29 @@ namespace Lucene.Net.Codecs.SimpleText
             {
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
                 var size = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMFIELDS.Length, scratch), CultureInfo.InvariantCulture);
                 var infos = new FieldInfo[size];
 
                 for (var i = 0; i < size; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
                     string name = ReadString(SimpleTextFieldInfosWriter.NAME.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
                     int fieldNumber = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMBER.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
                     bool isIndexed = Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.ISINDEXED.Length, scratch), CultureInfo.InvariantCulture);
 
                     IndexOptions indexOptions;
                     if (isIndexed)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
                         indexOptions = (IndexOptions)Enum.Parse(typeof(IndexOptions), ReadString(SimpleTextFieldInfosWriter.INDEXOPTIONS.Length,
                                 scratch));
                     }
@@ -89,46 +89,46 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
                     bool storeTermVector =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.STORETV.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
                     bool storePayloads =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.PAYLOADS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
                     bool omitNorms = !Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.NORMS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
                     string nrmType = ReadString(SimpleTextFieldInfosWriter.NORMS_TYPE.Length, scratch);
                     Index.DocValuesType normsType = DocValuesType(nrmType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
                     string dvType = ReadString(SimpleTextFieldInfosWriter.DOCVALUES.Length, scratch);
                     Index.DocValuesType docValuesType = DocValuesType(dvType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
                     long dvGen = Convert.ToInt64(ReadString(SimpleTextFieldInfosWriter.DOCVALUES_GEN.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
                     int numAtts = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUM_ATTS.Length, scratch), CultureInfo.InvariantCulture);
                     IDictionary<string, string> atts = new Dictionary<string, string>();
 
                     for (int j = 0; j < numAtts; j++)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
                         string key = ReadString(SimpleTextFieldInfosWriter.ATT_KEY.Length, scratch);
 
                         SimpleTextUtil.ReadLine(input, scratch);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
                         string value = ReadString(SimpleTextFieldInfosWriter.ATT_VALUE.Length, scratch);
                         atts[key] = value;
                     }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
index 949c682..7abfdcc 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     if (fi.IsIndexed)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         SimpleTextUtil.Write(output, INDEXOPTIONS);
                         SimpleTextUtil.Write(output, 
                             fi.IndexOptions != IndexOptions.NONE ? fi.IndexOptions.ToString() : string.Empty, 
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
index 7e0c8d0..9a2a97b 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
@@ -159,7 +159,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override BytesRef Next()
             {
-                //if (Debugging.AssertsEnabled) Debugging.Assert(() => !ended); // LUCENENET: Ended field is never set, so this can never fail
+                //if (Debugging.AssertsEnabled) Debugging.Assert(!ended); // LUCENENET: Ended field is never set, so this can never fail
                 var result = _fstEnum.Next();
 
                 if (result == null) return null;
@@ -316,8 +316,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     else
                     {
                         if (Debugging.AssertsEnabled) Debugging.Assert(
-                            () => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
-                            // LUCENENET TODO: This assert fails sometimes, which in turns causes _scratch.Utf8ToString() to throw an index out of range exception
+                            StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                             StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END), () => "scratch=" + _scratch.Utf8ToString());
 
                         if (!first && (_liveDocs == null || _liveDocs.Get(_docId)))
@@ -446,7 +445,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     else
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                                      StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END));
 
                         if (!first && (_liveDocs == null || _liveDocs.Get(_docId)))
@@ -472,7 +471,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readPositions)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.POS.Length, _scratch.Length - SimpleTextFieldsWriter.POS.Length,
                         _scratchUtf162);
                     pos = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
@@ -485,12 +484,12 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readOffsets)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.START_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.START_OFFSET.Length, _scratchUtf162);
                     _startOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), () => "got line=" + _scratch.Utf8ToString());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.END_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.END_OFFSET.Length, _scratchUtf162);
                     _endOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
index 31b85d9..9f39526 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
@@ -165,8 +165,8 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     if (Debugging.AssertsEnabled)
                     {
-                        Debugging.Assert(() => endOffset >= startOffset);
-                        Debugging.Assert(() => startOffset >= _lastStartOffset,
+                        Debugging.Assert(endOffset >= startOffset);
+                        Debugging.Assert(startOffset >= _lastStartOffset,
                             () => "startOffset=" + startOffset + " lastStartOffset=" + _lastStartOffset);
                     }
                     _lastStartOffset = startOffset;
@@ -180,7 +180,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                 if (payload != null && payload.Length > 0)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => payload.Length != 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(payload.Length != 0);
                     _outerInstance.Write(PAYLOAD);
                     _outerInstance.Write(payload);
                     _outerInstance.Newline();
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
index 0c2c553..bf1aaa5 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override IBits ReadLiveDocs(Directory dir, SegmentCommitInfo info, IOContext context)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => info.HasDeletions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(info.HasDeletions);
             var scratch = new BytesRef();
             var scratchUtf16 = new CharsRef();
 
@@ -80,7 +80,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 input = dir.OpenChecksumInput(fileName, context);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SIZE));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SIZE));
                 var size = ParseInt32At(scratch, SIZE.Length, scratchUtf16);
 
                 var bits = new BitSet(size);
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 SimpleTextUtil.ReadLine(input, scratch);
                 while (!scratch.Equals(END))
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, DOC));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, DOC));
                     var docid = ParseInt32At(scratch, DOC.Length, scratchUtf16);
                     bits.Set(docid);
                     SimpleTextUtil.ReadLine(input, scratch);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
index 8fdf142..3bcae92 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
@@ -53,43 +53,43 @@ namespace Lucene.Net.Codecs.SimpleText
             try
             {
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
                 string version = ReadString(SimpleTextSegmentInfoWriter.SI_VERSION.Length, scratch);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
                 int docCount = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_DOCCOUNT.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
                 bool isCompoundFile = Convert.ToBoolean(ReadString(SimpleTextSegmentInfoWriter.SI_USECOMPOUND.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
                 int numDiag = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_DIAG.Length, scratch), CultureInfo.InvariantCulture);
                 IDictionary<string, string> diagnostics = new Dictionary<string, string>();
 
                 for (int i = 0; i < numDiag; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
                     string key = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_KEY.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
                     string value = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_VALUE.Length, scratch);
                     diagnostics[key] = value;
                 }
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
                 int numFiles = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_FILES.Length, scratch), CultureInfo.InvariantCulture);
                 var files = new JCG.HashSet<string>();
 
                 for (int i = 0; i < numFiles; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
                     string fileName = ReadString(SimpleTextSegmentInfoWriter.SI_FILE.Length, scratch);
                     files.Add(fileName);
                 }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
index c17061f..d7afaa0 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
@@ -113,26 +113,26 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == _offsets.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(upto == _offsets.Length);
         }
 
         public override void VisitDocument(int n, StoredFieldVisitor visitor)
         {
             _input.Seek(_offsets[n]);
             ReadLine();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
+            if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
             var numFields = ParseInt32At(SimpleTextStoredFieldsWriter.NUM.Length);
 
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
                 int fieldNumber = ParseInt32At(SimpleTextStoredFieldsWriter.FIELD.Length);
                 FieldInfo fieldInfo = _fieldInfos.FieldInfo(fieldNumber);
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
 
                 BytesRef type;
                 if (EqualsAt(SimpleTextStoredFieldsWriter.TYPE_STRING, _scratch, SimpleTextStoredFieldsWriter.TYPE.Length))
@@ -171,7 +171,7 @@ namespace Lucene.Net.Codecs.SimpleText
                         break;
                     case StoredFieldVisitor.Status.NO:
                         ReadLine();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
                         break;
                     case StoredFieldVisitor.Status.STOP:
                         return;
@@ -182,7 +182,7 @@ namespace Lucene.Net.Codecs.SimpleText
         private void ReadField(BytesRef type, FieldInfo fieldInfo, StoredFieldVisitor visitor)
         {
             ReadLine();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+            if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
             if (Equals(type, SimpleTextStoredFieldsWriter.TYPE_STRING))
             {
                 visitor.StringField(fieldInfo,
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
index 71f23ab..729d5b4 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
@@ -109,7 +109,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto == _offsets.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(upto == _offsets.Length);
         }
 
         public override Fields Get(int doc)
@@ -119,7 +119,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             _input.Seek(_offsets[doc]);
             ReadLine();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
+            if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
             var numFields = ParseInt32At(SimpleTextTermVectorsWriter.NUMFIELDS.Length);
             if (numFields == 0)
             {
@@ -128,28 +128,28 @@ namespace Lucene.Net.Codecs.SimpleText
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
                 // skip fieldNumber:
                 ParseInt32At(SimpleTextTermVectorsWriter.FIELD.Length);
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
                 var fieldName = ReadString(SimpleTextTermVectorsWriter.FIELDNAME.Length, _scratch);
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
                 var positions = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPOSITIONS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
                 var offsets = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDOFFSETS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
                 var payloads = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPAYLOADS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
+                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
                 var termCount = ParseInt32At(SimpleTextTermVectorsWriter.FIELDTERMCOUNT.Length);
 
                 var terms = new SimpleTVTerms(offsets, positions, payloads);
@@ -158,7 +158,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 for (var j = 0; j < termCount; j++)
                 {
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
                     var term = new BytesRef();
                     var termLength = _scratch.Length - SimpleTextTermVectorsWriter.TERMTEXT.Length;
                     term.Grow(termLength);
@@ -169,7 +169,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     terms.terms.Add(term, postings);
 
                     ReadLine();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
                     postings.freq = ParseInt32At(SimpleTextTermVectorsWriter.TERMFREQ.Length);
 
                     if (!positions && !offsets) continue;
@@ -194,12 +194,12 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (positions)
                         {
                             ReadLine();
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
                             postings.positions[k] = ParseInt32At(SimpleTextTermVectorsWriter.POSITION.Length);
                             if (payloads)
                             {
                                 ReadLine();
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
+                                if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
                                 if (_scratch.Length - SimpleTextTermVectorsWriter.PAYLOAD.Length == 0)
                                 {
                                     postings.payloads[k] = null;
@@ -217,11 +217,11 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (!offsets) continue;
 
                         ReadLine();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
                         postings.startOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.STARTOFFSET.Length);
 
                         ReadLine();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
                         postings.endOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.ENDOFFSET.Length);
                     }
                 }
@@ -444,7 +444,7 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _freqRenamed != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(_freqRenamed != -1);
                     return _freqRenamed;
                 }
             }
@@ -495,7 +495,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     if (_positions != null)
                         return _positions.Length;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _startOffsets != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(_startOffsets != null);
                     return _startOffsets.Length;
                 }
             }
@@ -540,7 +540,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (_positions != null && _nextPos < _positions.Length) ||
+                if (Debugging.AssertsEnabled) Debugging.Assert((_positions != null && _nextPos < _positions.Length) ||
                     _startOffsets != null && _nextPos < _startOffsets.Length);
 
                 if (_positions != null)
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
index b2dd7ef..e178c3e 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
@@ -143,7 +143,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => _positions || _offsets);
+            if (Debugging.AssertsEnabled) Debugging.Assert(_positions || _offsets);
 
             if (_positions)
             {
@@ -156,7 +156,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     Write(PAYLOAD);
                     if (payload != null)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => payload.Length > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(payload.Length > 0);
                         Write(payload);
                     }
                     NewLine();
diff --git a/src/Lucene.Net.Expressions/ExpressionComparator.cs b/src/Lucene.Net.Expressions/ExpressionComparator.cs
index 4905386..0340201 100644
--- a/src/Lucene.Net.Expressions/ExpressionComparator.cs
+++ b/src/Lucene.Net.Expressions/ExpressionComparator.cs
@@ -49,11 +49,11 @@ namespace Lucene.Net.Expressions
             base.SetScorer(scorer);
             // TODO: might be cleaner to lazy-init 'source' and set scorer after?
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => readerContext != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(readerContext != null);
             try
             {
                 var context = new Dictionary<string, object>();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => scorer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(scorer != null);
                 context["scorer"] = scorer;
                 scores = source.GetValues(context, readerContext);
             }
diff --git a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
index a42d4ec..a28bc3f 100644
--- a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
+++ b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Expressions
         {
             try
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => document == scorer.DocID);
+                if (Debugging.AssertsEnabled) Debugging.Assert(document == scorer.DocID);
                 return scorer.GetScore();
             }
             catch (IOException exception)
diff --git a/src/Lucene.Net.Facet/DrillDownQuery.cs b/src/Lucene.Net.Facet/DrillDownQuery.cs
index 7d26a0e..40c050d 100644
--- a/src/Lucene.Net.Facet/DrillDownQuery.cs
+++ b/src/Lucene.Net.Facet/DrillDownQuery.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Facet
             {
                 throw new ArgumentException("cannot apply filter unless baseQuery isn't null; pass ConstantScoreQuery instead");
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => clauses.Length == 1 + other.drillDownDims.Count, () => clauses.Length + " vs " + (1 + other.drillDownDims.Count));
+            if (Debugging.AssertsEnabled) Debugging.Assert(clauses.Length == 1 + other.drillDownDims.Count, () => clauses.Length + " vs " + (1 + other.drillDownDims.Count));
             drillDownDims.PutAll(other.drillDownDims);
             query.Add(new FilteredQuery(clauses[0].Query, filter), Occur.MUST);
             for (int i = 1; i < clauses.Length; i++)
diff --git a/src/Lucene.Net.Facet/DrillSideways.cs b/src/Lucene.Net.Facet/DrillSideways.cs
index b144bb2..80d0509 100644
--- a/src/Lucene.Net.Facet/DrillSideways.cs
+++ b/src/Lucene.Net.Facet/DrillSideways.cs
@@ -175,7 +175,7 @@ namespace Lucene.Net.Facet
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => clauses.Length == 1 + drillDownDims.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(clauses.Length == 1 + drillDownDims.Count);
                 baseQuery = clauses[0].Query;
                 startClause = 1;
             }
diff --git a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
index ccbc0c2..afd9bc1 100644
--- a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
+++ b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
@@ -89,7 +89,7 @@ namespace Lucene.Net.Facet
             // TODO: if we ever allow null baseScorer ... it will
             // mean we DO score docs out of order ... hmm, or if we
             // change up the order of the conjuntions below
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => baseScorer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(baseScorer != null);
 
             // some scorers, eg ReqExlScorer, can hit NPE if cost is called after nextDoc
             long baseQueryCost = baseScorer.GetCost();
@@ -395,7 +395,7 @@ namespace Lucene.Net.Facet
                 while (slot0 < CHUNK && (slot0 = seen.NextSetBit(slot0)) != -1)
                 {
                     int ddDocID = docIDs[slot0];
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ddDocID != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ddDocID != -1);
 
                     int baseDocID = baseScorer.DocID;
                     if (baseDocID < ddDocID)
@@ -550,7 +550,7 @@ namespace Lucene.Net.Facet
                     //}
 
                     // Mark slot as valid:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docIDs[slot] != docID, () => "slot=" + slot + " docID=" + docID);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(docIDs[slot] != docID, () => "slot=" + slot + " docID=" + docID);
                     docIDs[slot] = docID;
                     scores[slot] = baseScorer.GetScore();
                     filledSlots[filledCount++] = slot;
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index b0f0f0e..5183065 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -694,7 +694,7 @@ namespace Lucene.Net.Facet
                 }
             }
             parts.Add(new string(buffer, 0, upto));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !lastEscape);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!lastEscape);
             return parts.ToArray();
         }
     }
diff --git a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
index 0641fc6..c8b8998 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => flags == 2);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(flags == 2);
                     // This point is only the end of an interval; attach
                     // it to last interval:
                     elementaryIntervals.Add(new InclusiveRange(prev, v));
@@ -275,7 +275,7 @@ namespace Lucene.Net.Facet.Range
 
             public InclusiveRange(long start, long end)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= start);
+                if (Debugging.AssertsEnabled) Debugging.Assert(end >= start);
                 this.Start = start;
                 this.End = end;
             }
@@ -349,7 +349,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else if (left != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(right != null);
                     // Recurse:
                     left.AddOutputs(index, range);
                     right.AddOutputs(index, range);
@@ -361,7 +361,7 @@ namespace Lucene.Net.Facet.Range
                 Indent(sb, depth);
                 if (left == null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right == null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(right == null);
                     sb.Append("leaf: " + start + " to " + end);
                 }
                 else
@@ -377,7 +377,7 @@ namespace Lucene.Net.Facet.Range
 
                 if (left != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => right != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(right != null);
                     left.ToString(sb, depth + 1);
                     right.ToString(sb, depth + 1);
                 }
diff --git a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
index 92f5d57..7f3f6b2 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLen > 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(prefixLen > 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
@@ -75,7 +75,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public CategoryPath(params string[] components)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => components.Length > 0, () => "use CategoryPath.EMPTY to create an empty path");
+            if (Debugging.AssertsEnabled) Debugging.Assert(components.Length > 0, () => "use CategoryPath.EMPTY to create an empty path");
             foreach (string comp in components)
             {
                 if (string.IsNullOrEmpty(comp))
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index 52df74c..79da91f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -190,7 +190,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             // verify (to some extent) that merge policy in effect would preserve category docids 
             if (indexWriter != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !(indexWriter.Config.MergePolicy is TieredMergePolicy), () => "for preserving category docids, merging none-adjacent segments is not allowed");
+                if (Debugging.AssertsEnabled) Debugging.Assert(!(indexWriter.Config.MergePolicy is TieredMergePolicy), () => "for preserving category docids, merging none-adjacent segments is not allowed");
             }
 
             // after we opened the writer, and the index is locked, it's safe to check
@@ -826,7 +826,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
                                 FacetLabel cp = new FacetLabel(FacetsConfig.StringToPath(t.Utf8ToString()));
                                 docsEnum = termsEnum.Docs(null, docsEnum, DocsFlags.NONE);
                                 bool res = cache.Put(cp, docsEnum.NextDoc() + ctx.DocBase);
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => !res, () => "entries should not have been evicted from the cache");
+                                if (Debugging.AssertsEnabled) Debugging.Assert(!res, () => "entries should not have been evicted from the cache");
                             }
                             else
                             {
@@ -907,7 +907,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             }
 
             int[] parents = GetTaxoArrays().Parents;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ordinal < parents.Length, () => "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
+            if (Debugging.AssertsEnabled) Debugging.Assert(ordinal < parents.Length, () => "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
             return parents[ordinal];
         }
 
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
index 52e71c9..dd5030e 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
@@ -77,7 +77,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         public TaxonomyIndexArrays(IndexReader reader, TaxonomyIndexArrays copyFrom)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => copyFrom != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(copyFrom != null);
 
             // note that copyParents.length may be equal to reader.maxDoc(). this is not a bug
             // it may be caused if e.g. the taxonomy segments were merged, and so an updated
diff --git a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
index c9bc017..562d80e 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
index b71ed1f..15e8233 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 if (ft.IsHierarchical && ft.IsMultiValued == false)
                 {
                     int dimRootOrd = m_taxoReader.GetOrdinal(new FacetLabel(dim));
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => dimRootOrd > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(dimRootOrd > 0);
                     m_values[dimRootOrd] += Rollup(m_children[dimRootOrd]);
                 }
             }
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
index fa4cec5..d3aee8f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
@@ -143,7 +143,7 @@ namespace Lucene.Net.Facet.Taxonomy
         public static T OpenIfChanged<T>(T oldTaxoReader) where T : TaxonomyReader
         {
             T newTaxoReader = (T)oldTaxoReader.DoOpenIfChanged();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => newTaxoReader != oldTaxoReader);
+            if (Debugging.AssertsEnabled) Debugging.Assert(newTaxoReader != oldTaxoReader);
             return newTaxoReader;
         }
 
diff --git a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
index 2e39fef..a7bd395 100644
--- a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
@@ -248,7 +248,7 @@ namespace Lucene.Net.Search.Grouping
                     bottomGroup = m_orderedGroups.Last();
                     m_orderedGroups.Remove(bottomGroup);
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_orderedGroups.Count == topNGroups - 1);
 
                 groupMap.Remove(bottomGroup.GroupValue);
 
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search.Grouping
 
                 groupMap[bottomGroup.GroupValue] = bottomGroup;
                 m_orderedGroups.Add(bottomGroup);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_orderedGroups.Count == topNGroups);
 
                 int lastComparerSlot = m_orderedGroups.Last().ComparerSlot;
                 foreach (FieldComparer fc in comparers)
@@ -315,7 +315,7 @@ namespace Lucene.Net.Search.Grouping
                     prevLast = m_orderedGroups.Last();
                     m_orderedGroups.Remove(group);
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_orderedGroups.Count == topNGroups - 1);
             }
             else
             {
@@ -333,7 +333,7 @@ namespace Lucene.Net.Search.Grouping
             if (m_orderedGroups != null)
             {
                 m_orderedGroups.Add(group);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_orderedGroups.Count == topNGroups);
                 var newLast = m_orderedGroups.Last();
                 // If we changed the value of the last group, or changed which group was last, then update bottom:
                 if (group == newLast || prevLast != newLast)
@@ -376,7 +376,7 @@ namespace Lucene.Net.Search.Grouping
             var comparer = new BuildSortedSetComparer(this);
             m_orderedGroups = new JCG.SortedSet<CollectedSearchGroup<TGroupValue>>(comparer);
             m_orderedGroups.UnionWith(groupMap.Values);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_orderedGroups.Count > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(m_orderedGroups.Count > 0);
 
             foreach (FieldComparer fc in comparers)
             {
diff --git a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
index 2934754..3d73f2d 100644
--- a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
@@ -155,8 +155,8 @@ namespace Lucene.Net.Search.Grouping
                 //System.out.println("    ltcheck");
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => group1 != group2);
-                    Debugging.Assert(() => group1.comparerSlot != group2.comparerSlot);
+                    Debugging.Assert(group1 != group2);
+                    Debugging.Assert(group1.comparerSlot != group2.comparerSlot);
                 }
 
                 int numComparers = outerInstance.comparers.Length;
@@ -224,7 +224,7 @@ namespace Lucene.Net.Search.Grouping
                 {
                     // Replace bottom element in PQ and then updateTop
                     OneGroup og = groupQueue.Top;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => og != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(og != null);
                     og.count = subDocUpto;
                     og.topGroupDoc = docBase + topGroupDoc;
                     // Swap pending docs
@@ -524,7 +524,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 if (subDocUpto == 1)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !queueFull);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!queueFull);
 
                     //System.out.println("    init copy to bottomSlot=" + bottomSlot);
                     foreach (FieldComparer fc in comparers)
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index 32f4756..680b257 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -186,12 +186,12 @@ namespace Lucene.Net.Search.Grouping
                 {
                     if (groupValue == null)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => otherMergedGroup.groupValue != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(otherMergedGroup.groupValue != null);
                     }
                     else
                     {
                         
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !groupValueIsValueType 
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!groupValueIsValueType 
                             ? JCG.EqualityComparer<T>.Default.Equals(groupValue, otherMergedGroup.groupValue)
 
                             // LUCENENET specific - use J2N.Collections.StructuralEqualityComparer.Default.Equals() if we have a reference type
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 // We never have another MergedGroup instance with
                 // same groupValue
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => NeverEquals(other));
+                if (Debugging.AssertsEnabled) Debugging.Assert(NeverEquals(other));
 
                 if (other is MergedGroup<T> otherMergedGroup)
                 {
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search.Grouping
                 }
 
                 // Tie break by min shard index:
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => group.MinShardIndex != other.MinShardIndex);
+                if (Debugging.AssertsEnabled) Debugging.Assert(group.MinShardIndex != other.MinShardIndex);
                 return group.MinShardIndex - other.MinShardIndex;
             }
         }
@@ -327,7 +327,7 @@ namespace Lucene.Net.Search.Grouping
                         //System.out.println("      new");
                         mergedGroup = new MergedGroup<T>(group.GroupValue);
                         mergedGroup.MinShardIndex = shard.ShardIndex;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => group.SortValues != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(group.SortValues != null);
                         mergedGroup.TopValues = group.SortValues;
                         groupsSeen[group.GroupValue] = mergedGroup;
                         mergedGroup.IsInQueue = true;
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index 2d65424..45ddcbc 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -175,7 +175,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     BytesRef facetEndPrefix = BytesRef.DeepCopyOf(m_facetPrefix);
                     facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
                     m_endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => m_endFacetOrd < 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(m_endFacetOrd < 0);
                     m_endFacetOrd = -m_endFacetOrd - 1; // Points to the ord one higher than facetEndPrefix
                 }
                 else
@@ -203,7 +203,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     this.m_mergePos = startFacetOrd == -1 ? 1 : startFacetOrd + 1;
                     if (m_mergePos < m_maxTermPos)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => tenum != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(tenum != null);
                         tenum.SeekExact(startFacetOrd == -1 ? 0 : startFacetOrd);
                         m_mergeTerm = tenum.Term;
                     }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
index ffc4b8e..a26ba1e 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
@@ -292,7 +292,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentStartOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentStartOffset >= 0);
                     return currentStartOffset;
                 }
             }
@@ -301,7 +301,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentEndOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentEndOffset >= 0);
                     return currentEndOffset;
                 }
             }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
index 22805b2..fa0f236 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
         internal void AddMatch(int startOffset, int endOffset, BytesRef term)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= this.startOffset && startOffset <= this.endOffset);
+            if (Debugging.AssertsEnabled) Debugging.Assert(startOffset >= this.startOffset && startOffset <= this.endOffset);
             if (numMatches == matchStarts.Length)
             {
                 int newLength = ArrayUtil.Oversize(numMatches + 1, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 matchEnds = newMatchEnds;
                 matchTerms = newMatchTerms;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
             matchStarts[numMatches] = startOffset;
             matchEnds[numMatches] = endOffset;
             matchTerms[numMatches] = term;
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
index b5b5a8a..09786eb 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
@@ -542,7 +542,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 AtomicReaderContext subContext = leaves[leaf];
                 AtomicReader r = subContext.AtomicReader;
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => leaf >= lastLeaf); // increasing order
+                if (Debugging.AssertsEnabled) Debugging.Assert(leaf >= lastLeaf); // increasing order
 
                 // if the segment has changed, we must initialize new enums.
                 if (leaf != lastLeaf)
@@ -671,7 +671,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 // LUCENE-5166: this hit would span the content limit... however more valid 
                 // hits may exist (they are sorted by start). so we pretend like we never 
                 // saw this term, it won't cause a passage to be added to passageQueue or anything.
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => EMPTY.StartOffset == int.MaxValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(EMPTY.StartOffset == int.MaxValue);
                 if (start < contentLength && end > contentLength)
                 {
                     continue;
@@ -714,7 +714,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                         return passages;
                     }
                     // advance breakiterator
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => BreakIterator.Done < 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(BreakIterator.Done < 0);
                     current.startOffset = Math.Max(bi.Preceding(start + 1), 0);
                     current.endOffset = Math.Min(bi.Next(), contentLength);
                 }
@@ -727,7 +727,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                     {
                         // multitermquery match, pull from payload
                         term = off.dp.GetPayload();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(term != null);
                     }
                     current.AddMatch(start, end, term);
                     if (off.pos == dp.Freq)
@@ -751,7 +751,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             }
 
             // Dead code but compiler disagrees:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+            if (Debugging.AssertsEnabled) Debugging.Assert(false);
             return null;
         }
 
@@ -766,7 +766,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             // BreakIterator should be un-next'd:
             List<Passage> passages = new List<Passage>();
             int pos = bi.Current;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => pos == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(pos == 0);
             while (passages.Count < maxPassages)
             {
                 int next = bi.Next();
@@ -883,7 +883,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public LimitedStoredFieldVisitor(string[] fields, char[] valueSeparators, int maxLength)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == valueSeparators.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fields.Length == valueSeparators.Length);
                 this.fields = fields;
                 this.valueSeparators = valueSeparators;
                 this.maxLength = maxLength;
@@ -896,7 +896,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public override void StringField(Index.FieldInfo fieldInfo, string value)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(currentField >= 0);
                 StringBuilder builder = builders[currentField];
                 if (builder.Length > 0 && builder.Length < maxLength)
                 {
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
index 7f656b8..1c328c2 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
@@ -142,7 +142,7 @@ namespace Lucene.Net.Search.VectorHighlight
             {
                 this.iter = iter;
                 T removeTop = RemoveTop();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => removeTop == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(removeTop == null);
             }
 
             public T Top()
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
index 9818598..fda9446 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Search.VectorHighlight
                 TermInfo current = termList[i];
                 if (current.Position == currentPos)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => previous != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(previous != null);
                     previous.SetNext(current);
                     previous = current;
                     //iterator.Remove();
diff --git a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
index 09d424a..f3e0297 100644
--- a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
@@ -246,7 +246,7 @@ namespace Lucene.Net.Join
                         }
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _childDoc < _parentDoc, () => "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(_childDoc < _parentDoc, () => "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
                     _childDoc++;
                     if (_acceptDocs != null && !_acceptDocs.Get(_childDoc))
                     {
@@ -280,7 +280,7 @@ namespace Lucene.Net.Join
 
             public override int Advance(int childTarget)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
+                if (Debugging.AssertsEnabled) Debugging.Assert(childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
 
                 //System.out.println("Q.advance childTarget=" + childTarget);
                 if (childTarget == NO_MORE_DOCS)
@@ -289,14 +289,14 @@ namespace Lucene.Net.Join
                     return _childDoc = _parentDoc = NO_MORE_DOCS;
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => _childDoc == -1 || childTarget != _parentDoc, () => "childTarget=" + childTarget);
+                if (Debugging.AssertsEnabled) Debugging.Assert(_childDoc == -1 || childTarget != _parentDoc, () => "childTarget=" + childTarget);
                 if (_childDoc == -1 || childTarget > _parentDoc)
                 {
                     // Advance to new parent:
                     _parentDoc = _parentScorer.Advance(childTarget);
                     ValidateParentDoc();
                     //System.out.println("  advance to parentDoc=" + parentDoc);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _parentDoc > childTarget);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(_parentDoc > childTarget);
                     if (_parentDoc == NO_MORE_DOCS)
                     {
                         //System.out.println("  END");
@@ -312,7 +312,7 @@ namespace Lucene.Net.Join
                     childTarget = Math.Max(childTarget, firstChild);
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => childTarget < _parentDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(childTarget < _parentDoc);
 
                 // Advance within children of current parent:
                 _childDoc = childTarget;
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
index 71deac5..61550ca 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
@@ -284,7 +284,7 @@ namespace Lucene.Net.Join
                     og.counts[scorerIDX] = joinScorer.ChildCount;
                     //System.out.println("    count=" + og.counts[scorerIDX]);
                     og.docs[scorerIDX] = joinScorer.SwapChildDocs(og.docs[scorerIDX]);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => og.docs[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(og.docs[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     //System.out.println("    len=" + og.docs[scorerIDX].length);
                     /*
                       for(int idx=0;idx<og.counts[scorerIDX];idx++) {
@@ -295,7 +295,7 @@ namespace Lucene.Net.Join
                     {
                         //System.out.println("    copy scores");
                         og.scores[scorerIDX] = joinScorer.SwapChildScores(og.scores[scorerIDX]);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => og.scores[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(og.scores[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     }
                 }
                 else
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
index 84f41fd..ae816ec 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
@@ -284,7 +284,7 @@ namespace Lucene.Net.Join
                     }
 
                     //System.out.println("  parentDoc=" + parentDoc);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => _parentDoc != -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(_parentDoc != -1);
 
                     //System.out.println("  nextChildDoc=" + nextChildDoc);
                     if (_acceptDocs != null && !_acceptDocs.Get(_parentDoc))
@@ -402,7 +402,7 @@ namespace Lucene.Net.Join
                 _prevParentDoc = _parentBits.PrevSetBit(parentTarget - 1);
 
                 //System.out.println("  rolled back to prevParentDoc=" + prevParentDoc + " vs parentDoc=" + parentDoc);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => _prevParentDoc >= _parentDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(_prevParentDoc >= _parentDoc);
                 if (_prevParentDoc > _nextChildDoc)
                 {
                     _nextChildDoc = _childScorer.Advance(_prevParentDoc);
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index c6ef1a5..6f6d3fc 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -250,7 +250,7 @@ namespace Lucene.Net.Index.Memory
                             return mid;
                         }
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => comparer.Compare(bytesRef, b) != 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(comparer.Compare(bytesRef, b) != 0);
                     return -(low + 1);
                 }
 
@@ -285,7 +285,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(long ord)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < info.terms.Count);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ord < info.terms.Count);
                     termUpto = (int)ord;
                 }
 
@@ -332,7 +332,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(BytesRef term, TermState state)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != null);
                     this.SeekExact(((OrdTermState)state).Ord);
                 }
 
@@ -452,8 +452,8 @@ namespace Lucene.Net.Index.Memory
                 {
                     if (Debugging.AssertsEnabled)
                     {
-                        Debugging.Assert(() => posUpto++ < freq);
-                        Debugging.Assert(() => !sliceReader.IsEndOfSlice, () => " stores offsets : " + startOffset);
+                        Debugging.Assert(posUpto++ < freq);
+                        Debugging.Assert(!sliceReader.IsEndOfSlice, () => " stores offsets : " + startOffset);
                     }
                     if (outerInstance.outerInstance.storeOffsets)
                     {
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index 18df8c9..19ea43e 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -217,7 +217,7 @@ namespace Lucene.Net.Index.Memory
             this.bytesUsed = Counter.NewCounter();
             int maxBufferedByteBlocks = (int)((maxReusedBytes / 2) / ByteBlockPool.BYTE_BLOCK_SIZE);
             int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
+            if (Debugging.AssertsEnabled) Debugging.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
             byteBlockPool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, maxBufferedByteBlocks, bytesUsed));
             intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT32_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
             postingsWriter = new Int32BlockPool.SliceWriter(intBlockPool);
@@ -741,9 +741,9 @@ namespace Lucene.Net.Index.Memory
                 freq = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => start.Length >= ord.Length);
-                    Debugging.Assert(() => end.Length >= ord.Length);
-                    Debugging.Assert(() => freq.Length >= ord.Length);
+                    Debugging.Assert(start.Length >= ord.Length);
+                    Debugging.Assert(end.Length >= ord.Length);
+                    Debugging.Assert(freq.Length >= ord.Length);
                 }
                 return ord;
             }
@@ -759,9 +759,9 @@ namespace Lucene.Net.Index.Memory
                 }
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => start.Length >= ord.Length);
-                    Debugging.Assert(() => end.Length >= ord.Length);
-                    Debugging.Assert(() => freq.Length >= ord.Length);
+                    Debugging.Assert(start.Length >= ord.Length);
+                    Debugging.Assert(end.Length >= ord.Length);
+                    Debugging.Assert(freq.Length >= ord.Length);
                 }
                 return ord;
             }
diff --git a/src/Lucene.Net.Misc/Document/LazyDocument.cs b/src/Lucene.Net.Misc/Document/LazyDocument.cs
index bc2aa77..3e6e751 100644
--- a/src/Lucene.Net.Misc/Document/LazyDocument.cs
+++ b/src/Lucene.Net.Misc/Document/LazyDocument.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Documents
             fields.TryGetValue(fieldNum, out lazyValues);
             IIndexableField[] realValues = d.GetFields(name);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => realValues.Length <= lazyValues.Count,
+            if (Debugging.AssertsEnabled) Debugging.Assert(realValues.Length <= lazyValues.Count,
                 () => "More lazy values then real values for field: " + name);
 
             for (int i = 0; i < lazyValues.Count; i++)
@@ -166,8 +166,8 @@ namespace Lucene.Net.Documents
                 }
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => HasBeenLoaded, () => "field value was not lazy loaded");
-                    Debugging.Assert(() => realValue.Name.Equals(Name, StringComparison.Ordinal), () => "realvalue name != name: " + realValue.Name + " != " + Name);
+                    Debugging.Assert(HasBeenLoaded, () => "field value was not lazy loaded");
+                    Debugging.Assert(realValue.Name.Equals(Name, StringComparison.Ordinal), () => "realvalue name != name: " + realValue.Name + " != " + Name);
                 }
 
                 return realValue;
diff --git a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
index 17695f7..29c6f00 100644
--- a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
@@ -297,7 +297,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => oldLiveDocs != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(oldLiveDocs != null);
                     // this loop is a little bit ineffective, as Bits has no nextSetBit():
                     for (int i = 0; i < maxDoc; i++)
                     {
diff --git a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
index 8f96af9..b90a713 100644
--- a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => oldLiveDocs != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(oldLiveDocs != null);
                     DocIdSetIterator it = bits.GetIterator();
                     for (int i = it.NextDoc(); i < maxDoc; i = it.NextDoc())
                     {
diff --git a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
index cfff119..4aacfc4 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
@@ -85,8 +85,8 @@ namespace Lucene.Net.Index.Sorter
                 int oldID = docMap.NewToOld(newID);
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => newID >= 0 && newID < maxDoc, () => "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
-                    Debugging.Assert(() => i == oldID, () => "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
+                    Debugging.Assert(newID >= 0 && newID < maxDoc, () => "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
+                    Debugging.Assert(i == oldID, () => "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
                 }
                 if (i != oldID || newID < 0 || newID >= maxDoc)
                 {
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 6374533..bb6eace 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -761,7 +761,7 @@ namespace Lucene.Net.Index.Sorter
             {
                 throw new ArgumentException("reader.MaxDoc should be equal to docMap.Count, got" + reader.MaxDoc + " != " + docMap.Count);
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Sorter.IsConsistent(docMap));
+            if (Debugging.AssertsEnabled) Debugging.Assert(Sorter.IsConsistent(docMap));
             return new SortingAtomicReader(reader, docMap);
         }
 
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index 7028244..c692723 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -134,7 +134,7 @@ namespace Lucene.Net.Index.Sorter
                 {
                     return base.GetDocMap(mergeState);
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => mergeState.DocMaps.Length == 1); // we returned a singleton reader
+                if (Debugging.AssertsEnabled) Debugging.Assert(mergeState.DocMaps.Length == 1); // we returned a singleton reader
                 MonotonicAppendingInt64Buffer deletes = GetDeletes(unsortedReaders);
                 return new DocMapAnonymousInnerClassHelper(this, mergeState, deletes);
             }
diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
index 03da23b..bf03c34 100644
--- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !(prefix is IList));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!(prefix is IList));
             if (!(output is IList))
             {
                 return outputs.Add((T)prefix, (T)output);
@@ -107,7 +107,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !(output is IList));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!(output is IList));
             outputs.Write((T)output, @out);
         }
 
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index 40b4361..b5a3e93 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -72,8 +72,8 @@ namespace Lucene.Net.Util.Fst
                 this.second = second;
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => first >= 0);
-                    Debugging.Assert(() => second >= 0);
+                    Debugging.Assert(first >= 0);
+                    Debugging.Assert(second >= 0);
                 }
             }
 
@@ -139,8 +139,8 @@ namespace Lucene.Net.Util.Fst
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => Valid(output1, false));
-                Debugging.Assert(() => Valid(output2, false));
+                Debugging.Assert(Valid(output1, false));
+                Debugging.Assert(Valid(output2, false));
             }
             long? output1_ = (long?)output1;
             long? output2_ = (long?)output2;
@@ -152,8 +152,8 @@ namespace Lucene.Net.Util.Fst
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => output1_ > 0);
-                    Debugging.Assert(() => output2_ > 0);
+                    Debugging.Assert(output1_ > 0);
+                    Debugging.Assert(output2_ > 0);
                 }
                 return Math.Min(output1_.GetValueOrDefault(), output2_.GetValueOrDefault());
             }
@@ -171,12 +171,12 @@ namespace Lucene.Net.Util.Fst
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => Valid(output, false));
-                Debugging.Assert(() => Valid(inc, false));
+                Debugging.Assert(Valid(output, false));
+                Debugging.Assert(Valid(inc, false));
             }
             long? output2 = (long?)output;
             long? inc2 = (long?)inc;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => output2 >= inc2);
+            if (Debugging.AssertsEnabled) Debugging.Assert(output2 >= inc2);
 
             if (inc2 == NO_OUTPUT)
             {
@@ -194,8 +194,8 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(prefix, false));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(output, true));
+            if (Debugging.AssertsEnabled) Debugging.Assert(Valid(prefix, false));
+            if (Debugging.AssertsEnabled) Debugging.Assert(Valid(output, true));
             long? prefix2 = (long?)prefix;
             if (output is long?)
             {
@@ -223,7 +223,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Valid(output, true));
+            if (Debugging.AssertsEnabled) Debugging.Assert(Valid(output, true));
             if (output is long?)
             {
                 long? output2 = (long?)output;
@@ -264,9 +264,9 @@ namespace Lucene.Net.Util.Fst
 
         private bool Valid(long? o)
         {
-            Debugging.Assert(() => o != null);
-            Debugging.Assert(() => o is long?);
-            Debugging.Assert(() => o == NO_OUTPUT || o > 0);
+            Debugging.Assert(o != null);
+            Debugging.Assert(o is long?);
+            Debugging.Assert(o == NO_OUTPUT || o > 0);
             return true;
         }
 
@@ -275,7 +275,7 @@ namespace Lucene.Net.Util.Fst
         {
             if (!allowDouble)
             {
-                Debugging.Assert(() => o is long?);
+                Debugging.Assert(o is long?);
                 return Valid((long?)o);
             }
             else if (o is TwoInt64s)
@@ -300,8 +300,8 @@ namespace Lucene.Net.Util.Fst
         {
             if (Debugging.AssertsEnabled)
             {
-                Debugging.Assert(() => Valid(first, false));
-                Debugging.Assert(() => Valid(second, false));
+                Debugging.Assert(Valid(first, false));
+                Debugging.Assert(Valid(second, false));
             }
             return new TwoInt64s(((long?)first).GetValueOrDefault(), ((long?)second).GetValueOrDefault());
         }
diff --git a/src/Lucene.Net.Queries/BooleanFilter.cs b/src/Lucene.Net.Queries/BooleanFilter.cs
index d15cee8..164985c 100644
--- a/src/Lucene.Net.Queries/BooleanFilter.cs
+++ b/src/Lucene.Net.Queries/BooleanFilter.cs
@@ -78,7 +78,7 @@ namespace Lucene.Net.Queries
                 {
                     if (res == null)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !hasShouldClauses);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!hasShouldClauses);
                         res = new FixedBitSet(reader.MaxDoc);
                         res.Set(0, reader.MaxDoc); // NOTE: may set bits on deleted docs
                     }
diff --git a/src/Lucene.Net.Queries/CommonTermsQuery.cs b/src/Lucene.Net.Queries/CommonTermsQuery.cs
index e78ce71..053ff1e 100644
--- a/src/Lucene.Net.Queries/CommonTermsQuery.cs
+++ b/src/Lucene.Net.Queries/CommonTermsQuery.cs
@@ -279,7 +279,7 @@ namespace Lucene.Net.Queries
                         continue;
                     }
                     termsEnum = terms.GetIterator(termsEnum);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null);
 
                     if (termsEnum == TermsEnum.EMPTY)
                     {
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
index f4d4c5f..5a220bf 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
@@ -182,7 +182,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                     {
                         bool hasNext;
                         hasNext = buffer.IncrementToken();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(hasNext == true);
                         term = termAtt.ToString();
                     }
 #pragma warning disable 168
@@ -213,7 +213,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -240,7 +240,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -307,7 +307,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                             try
                             {
                                 bool hasNext = buffer.IncrementToken();
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(hasNext == true);
                                 term = termAtt.ToString();
                                 if (posIncrAtt != null)
                                 {
@@ -379,7 +379,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         try
                         {
                             bool hasNext = buffer.IncrementToken();
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext == true);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(hasNext == true);
                             term = termAtt.ToString();
 
                             if (posIncrAtt != null)
diff --git a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
index 009ad62..0cb8bac 100644
--- a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
@@ -242,7 +242,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumeSubQuery(State state)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => (m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert((m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
             int start = ++state.Index;
             int precedence = 1;
             bool escaped = false;
@@ -315,7 +315,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumePhrase(State state)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => (m_flags & Operator.PHRASE_OPERATOR) != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert((m_flags & Operator.PHRASE_OPERATOR) != 0);
             int start = ++state.Index;
             int copied = 0;
             bool escaped = false;
diff --git a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
index eddc6f0..8793c80 100644
--- a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
@@ -187,7 +187,7 @@ namespace Lucene.Net.Replicator
         /// <exception cref="IOException"></exception>
         public virtual Stream Open(string source, string fileName)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
+            if (Debugging.AssertsEnabled) Debugging.Assert(source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
             IndexCommit commit = source.Equals(INDEX_SOURCE, StringComparison.Ordinal) ? indexCommit : taxonomyCommit;
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
diff --git a/src/Lucene.Net.Replicator/IndexRevision.cs b/src/Lucene.Net.Replicator/IndexRevision.cs
index 3a97ead..d454d13 100644
--- a/src/Lucene.Net.Replicator/IndexRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexRevision.cs
@@ -134,7 +134,7 @@ namespace Lucene.Net.Replicator
 
         public virtual Stream Open(string source, string fileName)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => source.Equals(SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected={0} got={1}", SOURCE, source));
+            if (Debugging.AssertsEnabled) Debugging.Assert(source.Equals(SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected={0} got={1}", SOURCE, source));
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
 
diff --git a/src/Lucene.Net.Replicator/ReplicationClient.cs b/src/Lucene.Net.Replicator/ReplicationClient.cs
index 35251e6..a9a7844 100644
--- a/src/Lucene.Net.Replicator/ReplicationClient.cs
+++ b/src/Lucene.Net.Replicator/ReplicationClient.cs
@@ -370,7 +370,7 @@ namespace Lucene.Net.Replicator
                 // make sure to preserve revisionFiles order
                 List<RevisionFile> res = new List<RevisionFile>();
                 string source = e.Key;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => newRevisionFiles.ContainsKey(source), () => string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
+                if (Debugging.AssertsEnabled) Debugging.Assert(newRevisionFiles.ContainsKey(source), () => string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
                 foreach (RevisionFile file in newRevisionFiles[source])
                 {
                     if (!handlerFiles.Contains(file.FileName))
@@ -416,7 +416,7 @@ namespace Lucene.Net.Replicator
             updateThread = new ReplicationThread(intervalMillis, threadName, DoUpdate, HandleUpdateException, updateLock);
             updateThread.Start();
             // we rely on isAlive to return true in isUpdateThreadAlive, assert to be on the safe side
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => updateThread.IsAlive, () => "updateThread started but not alive?");
+            if (Debugging.AssertsEnabled) Debugging.Assert(updateThread.IsAlive, () => "updateThread started but not alive?");
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
index 265e06f..34f2783 100644
--- a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
@@ -191,7 +191,7 @@ namespace Lucene.Net.Sandbox.Queries
                         case Selector.MIDDLE_MAX: return new MiddleMaxValue(randomOrds);
                         case Selector.MIN:
                         default:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(false);
                             return null;
                     }
                 }
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
index 3e5da90..2a906eb 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
@@ -113,7 +113,7 @@ namespace Lucene.Net.Spatial.Prefix
             protected virtual void CollectDocs(FixedBitSet bitSet)
             {
                 //WARN: keep this specialization in sync
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_termsEnum != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_termsEnum != null);
                 m_docsEnum = m_termsEnum.Docs(m_acceptDocs, m_docsEnum, DocsFlags.NONE);
                 int docid;
                 while ((docid = m_docsEnum.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
index 033eb93..9edae90 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Spatial.Prefix
             : base(queryShape, fieldName, grid, detailLevel)
         {
             this.m_prefixGridScanLevel = Math.Max(0, Math.Min(prefixGridScanLevel, grid.MaxLevels - 1));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => detailLevel <= grid.MaxLevels);
+            if (Debugging.AssertsEnabled) Debugging.Assert(detailLevel <= grid.MaxLevels);
         }
 
         public override bool Equals(object o)
@@ -135,7 +135,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             public virtual DocIdSet GetDocIdSet()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => curVNode == null, () => "Called more than once?");
+                if (Debugging.AssertsEnabled) Debugging.Assert(curVNode == null, () => "Called more than once?");
                 if (m_termsEnum == null)
                 {
                     return null;
@@ -169,7 +169,7 @@ namespace Lucene.Net.Spatial.Prefix
                         // LUCENENET IMPORTANT: Must not call this inline with Debug.Assert
                         // because the compiler removes Debug.Assert statements in release mode!!
                         bool hasNext = curVNode.children.MoveNext();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(hasNext);
 
                         curVNode = curVNode.children.Current;
                     }
@@ -206,7 +206,7 @@ namespace Lucene.Net.Spatial.Prefix
                     if (compare > 0)
                     {
                         // leap frog (termsEnum is beyond where we would otherwise seek)
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), () => "should be absent");
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), () => "should be absent");
                     }
                     else
                     {
@@ -250,7 +250,7 @@ namespace Lucene.Net.Spatial.Prefix
             /// <exception cref="IOException"></exception>
             private void AddIntersectingChildren()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => thisTerm != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(thisTerm != null);
                 Cell cell = curVNode.cell;
                 if (cell.Level >= m_outerInstance.m_detailLevel)
                 {
@@ -261,7 +261,7 @@ namespace Lucene.Net.Spatial.Prefix
                 {
                     //If the next indexed term just adds a leaf marker ('+') to cell,
                     // then add all of those docs
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
+                    if (Debugging.AssertsEnabled) Debugging.Assert(StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
                     scanCell = m_outerInstance.m_grid.GetCell(thisTerm.Bytes, thisTerm.Offset, thisTerm.Length, scanCell);
                     if (scanCell.Level == cell.Level && scanCell.IsLeaf)
                     {
@@ -490,9 +490,9 @@ namespace Lucene.Net.Spatial.Prefix
 
             internal virtual void Reset(Cell cell)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => cell != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(cell != null);
                 this.cell = cell;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => children == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(children == null);
             }
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
index 80d2039..88f2e3a 100644
--- a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Spatial.Prefix
                 if (cell.Level != 0 && ((cell.ShapeRel == SpatialRelation.NOT_SET || cell.ShapeRel == SpatialRelation.WITHIN)))
                 {
                     subCellsFilter = null;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
                 }
                 ICollection<Cell> subCells = cell.GetSubCells(subCellsFilter);
                 foreach (Cell subCell in subCells)
@@ -147,7 +147,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private bool SeekExact(Cell cell)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
                 this.termBytes.Bytes = cell.GetTokenBytes();
                 this.termBytes.Length = this.termBytes.Bytes.Length;
                 if (m_termsEnum == null)
@@ -157,7 +157,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private SmallDocSet GetDocs(Cell cell, IBits acceptContains)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
+                if (Debugging.AssertsEnabled) Debugging.Assert(new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
                 return this.CollectDocs(acceptContains);
             }
 
@@ -167,8 +167,8 @@ namespace Lucene.Net.Spatial.Prefix
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
-                    Debugging.Assert(() => !leafCell.Equals(lastLeaf));//don't call for same leaf again
+                    Debugging.Assert(new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
+                    Debugging.Assert(!leafCell.Equals(lastLeaf));//don't call for same leaf again
                 }
                 lastLeaf = leafCell;
 
@@ -301,7 +301,7 @@ namespace Lucene.Net.Spatial.Prefix
                     }
                     docs[d++] = v;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => d == intSet.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(d == intSet.Count);
                 int size = d;
                 //sort them
                 Array.Sort(docs, 0, size);
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
index e4fcc52..7ae545e 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
@@ -104,7 +104,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public virtual void Reset(byte[] bytes, int off, int len)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Level != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(Level != 0);
             token = null;
             m_shapeRel = SpatialRelation.NOT_SET;
             this.bytes = bytes;
@@ -139,7 +139,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
         /// <summary>Note: not supported at level 0.</summary>
         public virtual void SetLeaf()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => Level != 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(Level != 0);
             m_leaf = true;
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
index b6b76f4..a24056c 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
@@ -171,7 +171,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => str.Length == level);
+            if (Debugging.AssertsEnabled) Debugging.Assert(str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
@@ -197,7 +197,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => str.Length == level);
+            if (Debugging.AssertsEnabled) Debugging.Assert(str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
index 36a45f3..3d00c3a 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
@@ -48,7 +48,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public SpatialPrefixTree(SpatialContext ctx, int maxLevels)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => maxLevels > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(maxLevels > 0);
             this.m_ctx = ctx;
             this.m_maxLevels = maxLevels;
         }
@@ -269,7 +269,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
                 return new ReadOnlyCollection<Cell>(new[] { cell });
             }
             string endToken = cell.TokenString;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => endToken.Length == detailLevel);
+            if (Debugging.AssertsEnabled) Debugging.Assert(endToken.Length == detailLevel);
             IList<Cell> cells = new List<Cell>(detailLevel);
             for (int i = 1; i < detailLevel; i++)
             {
diff --git a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
index 5b33da7..ca1f64d 100644
--- a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
@@ -205,8 +205,8 @@ namespace Lucene.Net.Spatial.Prefix
                 //visitRelation is declared as a field, populated by visit() so we don't recompute it
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => m_outerInstance.m_detailLevel != cell.Level);
-                    Debugging.Assert(() => visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
+                    Debugging.Assert(m_outerInstance.m_detailLevel != cell.Level);
+                    Debugging.Assert(visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
                 }
                 if (AllCellsIntersectQuery(cell, visitRelation))
                 {
diff --git a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
index 391f23e..3b2fc96 100644
--- a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
+++ b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
@@ -104,7 +104,7 @@ namespace Lucene.Net.Spatial.Vector
                 // make sure it has minX and area
                 if (validX.Get(doc))
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => validY.Get(doc));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(validY.Get(doc));
                     return calculator.Distance(outerInstance.from, ptX.Get(doc), ptY.Get(doc)) * outerInstance.multiplier;
                 }
                 return nullValue;
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index 0be20a5..4cba458 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -270,7 +270,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 IList<Transition> newTransitions = new List<Transition>();
                 foreach (Transition t in state.GetTransitions())
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => t.Min == t.Max);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(t.Min == t.Max);
                     if (t.Min == TokenStreamToAutomaton.POS_SEP)
                     {
                         if (preserveSep)
@@ -361,8 +361,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 long bCost = readerB.ReadInt32();
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => DecodeWeight(aCost) >= 0);
-                    Debugging.Assert(() => DecodeWeight(bCost) >= 0);
+                    Debugging.Assert(DecodeWeight(aCost) >= 0);
+                    Debugging.Assert(DecodeWeight(bCost) >= 0);
                 }
                 if (aCost < bCost)
                 {
@@ -490,7 +490,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             output.WriteBytes(surfaceForm.Bytes, surfaceForm.Offset, surfaceForm.Length);
                         }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => output.Position == requiredLength, () => output.Position + " vs " + requiredLength);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(output.Position == requiredLength, () => output.Position + " vs " + requiredLength);
 
                         writer.Write(buffer, 0, output.Position);
                     }
@@ -664,7 +664,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         break;
                     }
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sepIndex != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(sepIndex != -1);
                 spare.Grow(sepIndex);
 
                 int payloadLen = output2.Length - sepIndex - 1;
@@ -710,7 +710,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         public override IList<LookupResult> DoLookup(string key, IEnumerable<BytesRef> contexts, bool onlyMorePopular, int num)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => num > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(num > 0);
 
             if (onlyMorePopular)
             {
@@ -802,7 +802,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     }
 
                     var completions = searcher.Search();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(completions.IsComplete);
 
                     // NOTE: this is rather inefficient: we enumerate
                     // every matching "exactly the same analyzed form"
@@ -845,7 +845,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
 
                 var completions2 = searcher2.Search();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => completions2.IsComplete);
+                if (Debugging.AssertsEnabled) Debugging.Assert(completions2.IsComplete);
 
                 foreach (Util.Fst.Util.Result<PairOutputs<long?, BytesRef>.Pair> completion in completions2)
                 {
@@ -923,7 +923,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         // We found exact match, which means we should
                         // have already found it in the first search:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => results.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(results.Count == 1);
                         return false;
                     }
                     else
@@ -967,7 +967,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             ReplaceSep(automaton);
             automaton = ConvertAutomaton(automaton);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => SpecialOperations.IsFinite(automaton));
+            if (Debugging.AssertsEnabled) Debugging.Assert(SpecialOperations.IsFinite(automaton));
 
             // Get all paths from the automaton (there can be
             // more than one path, eg if the analyzer created a
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
index a0c70e4..3b1c8f5 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
@@ -145,7 +145,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         {
 
             BinaryDocValues textDV = MultiDocValues.GetBinaryValues(searcher.IndexReader, TEXT_FIELD_NAME);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => textDV != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(textDV != null);
 
             // This will just be null if app didn't pass payloads to build():
             // TODO: maybe just stored fields?  they compress...
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index fbb56ad..53d613d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// </summary>
         public static IList<Path<T>> IntersectPrefixPaths<T>(Automaton a, FST<T> fst)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => a.IsDeterministic);
+            if (Debugging.AssertsEnabled) Debugging.Assert(a.IsDeterministic);
             IList<Path<T>> queue = new List<Path<T>>();
             List<Path<T>> endNodes = new List<Path<T>>();
             queue.Add(new Path<T>(a.GetInitialState(), fst.GetFirstArc(new FST.Arc<T>()), fst.Outputs.NoOutput, new Int32sRef()));
@@ -120,8 +120,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         FST.Arc<T> nextArc = Lucene.Net.Util.Fst.Util.ReadCeilArc(min, fst, path.FstNode, scratchArc, fstReader);
                         while (nextArc != null && nextArc.Label <= max)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc.Label <= max);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc.Label >= min, () => nextArc.Label + " " + min);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(nextArc.Label <= max);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(nextArc.Label >= min, () => nextArc.Label + " " + min);
                             Int32sRef newInput = new Int32sRef(currentInput.Length + 1);
                             newInput.CopyInt32s(currentInput);
                             newInput.Int32s[currentInput.Length] = nextArc.Label;
@@ -130,7 +130,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                               .CopyFrom(nextArc), fst.Outputs.Add(path.Output, nextArc.Output), newInput));
                             int label = nextArc.Label; // used in assert
                             nextArc = nextArc.IsLast ? null : fst.ReadNextRealArc(nextArc, fstReader);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextArc == null || label < nextArc.Label, () => "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(nextArc == null || label < nextArc.Label, () => "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
                         }
                     }
                 }
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index 2b79029..040d19a 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -556,7 +556,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     // a separate dedicated att for this?
                     int gramCount = posLenAtt.PositionLength;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => gramCount <= grams);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(gramCount <= grams);
 
                     // Safety: make sure the recalculated count "agrees":
                     if (CountGrams(tokenBytes) != gramCount)
@@ -682,7 +682,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             BytesRef context = new BytesRef(token.Bytes, token.Offset, i);
                             long? output = Lucene.Net.Util.Fst.Util.Get(fst, Lucene.Net.Util.Fst.Util.ToInt32sRef(context, new Int32sRef()));
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(output != null);
                             contextCount = DecodeWeight(output);
                             lastTokenFragment = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                             break;
@@ -699,7 +699,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         finalLastToken = BytesRef.DeepCopyOf(lastTokenFragment);
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => finalLastToken.Offset == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(finalLastToken.Offset == 0);
 
                     CharsRef spare = new CharsRef();
 
@@ -726,7 +726,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         searcher.AddStartPaths(arc, prefixOutput, true, new Int32sRef());
 
                         completions = searcher.Search();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(completions.IsComplete);
                     }
                     catch (IOException bogus)
                     {
@@ -754,7 +754,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             if (token.Bytes[token.Offset + i] == separator)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => token.Length - i - 1 > 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(token.Length - i - 1 > 0);
                                 lastToken = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                                 break;
                             }
@@ -772,7 +772,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             // return numbers that are greater than long.MaxValue, which results in a negative long number.
                             (long)(long.MaxValue * (decimal)backoff * ((decimal)DecodeWeight(completion.Output)) / contextCount));
                         results.Add(result);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => results.Count == seen.Count);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(results.Count == seen.Count);
                     //System.out.println("  add result=" + result);
                     nextCompletionContinue:;
                     }
@@ -874,7 +874,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         //private long decodeWeight(Pair<Long,BytesRef> output) {
         private static long DecodeWeight(long? output)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => output != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(output != null);
             return (int)(long.MaxValue - output); // LUCENENET TODO: Perhaps a Java Lucene bug? Why cast to int when returning long?
         }
 
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
index 8f909db..424420d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
@@ -115,7 +115,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         m_input.End();
                         endState = CaptureState();
                         int finalEndOffset = offsetAtt.EndOffset;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => finalEndOffset >= endOffset);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(finalEndOffset >= endOffset);
                         if (finalEndOffset > endOffset)
                         {
                             // OK there was a token separator after the
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
index afdfc8d..0aa067e 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -407,7 +407,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 output.Bytes = ArrayUtil.Grow(output.Bytes);
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => output.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(output.Offset == 0);
             output.Bytes[output.Length++] = (byte) arc.Label;
             FST.BytesReader fstReader = automaton.GetBytesReader();
             automaton.ReadFirstTargetArc(arc, arc, fstReader);
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index 8efcd39..e793931 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 throw new ArgumentException("this suggester doesn't support contexts");
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => num > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(num > 0);
 
             if (onlyMorePopular)
             {
@@ -190,7 +190,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             try
             {
                 completions = Lucene.Net.Util.Fst.Util.ShortestPaths(fst, arc, prefixOutput, weightComparer, num, !exactFirst);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => completions.IsComplete);
+                if (Debugging.AssertsEnabled) Debugging.Assert(completions.IsComplete);
             }
             catch (IOException bogus)
             {
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         private long? LookupPrefix(BytesRef scratch, FST.Arc<long?> arc) //Bogus
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => 0 == (long)fst.Outputs.NoOutput);
+            if (Debugging.AssertsEnabled) Debugging.Assert(0 == (long)fst.Outputs.NoOutput);
             long output = 0;
             var bytesReader = fst.GetBytesReader();
 
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search.Suggest.Fst
                 : base(source)
             {
                 this.outerInstance = outerInstance;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => source.HasPayloads == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(source.HasPayloads == false);
             }
 
             protected internal override void Encode(OfflineSorter.ByteSequencesWriter writer, ByteArrayDataOutput output, byte[] buffer, BytesRef spare, BytesRef payload, ICollection<BytesRef> contexts, long weight)
diff --git a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
index 4b8791f..d7891b7 100644
--- a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search.Suggest
         {
             get
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(currentOrd == ords[m_curPos]);
                 return m_freqs[currentOrd];
             }
         }
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasPayloads && m_curPos < m_payloads.Length)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentOrd == ords[m_curPos]);
                     return m_payloads.Get(payloadSpare, currentOrd);
                 }
                 return null;
@@ -96,7 +96,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasContexts && m_curPos < m_contextSets.Count)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentOrd == ords[m_curPos]);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentOrd == ords[m_curPos]);
                     return m_contextSets[currentOrd];
                 }
                 return null;
diff --git a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
index f20029b..ba0518b 100644
--- a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
@@ -78,7 +78,7 @@ namespace Lucene.Net.Analysis
 
             public virtual AttributeSource.State NextState()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => NextRead < InputTokens.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(NextRead < InputTokens.Count);
                 return InputTokens[NextRead++];
             }
         }
@@ -141,7 +141,7 @@ namespace Lucene.Net.Analysis
                 m_positions.Get(m_inputPos).Add(CaptureState());
                 tokenPending = false;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !insertPending);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!insertPending);
             insertPending = true;
         }
 
@@ -184,8 +184,8 @@ namespace Lucene.Net.Analysis
             {
                 Console.WriteLine("LTF.peekToken inputPos=" + m_inputPos + " outputPos=" + m_outputPos + " tokenPending=" + tokenPending);
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !m_end);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_inputPos == -1 || m_outputPos <= m_inputPos);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!m_end);
+            if (Debugging.AssertsEnabled) Debugging.Assert(m_inputPos == -1 || m_outputPos <= m_inputPos);
             if (tokenPending)
             {
                 m_positions.Get(m_inputPos).Add(CaptureState());
@@ -199,7 +199,7 @@ namespace Lucene.Net.Analysis
             if (gotToken)
             {
                 m_inputPos += m_posIncAtt.PositionIncrement;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => m_inputPos >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(m_inputPos >= 0);
                 if (DEBUG)
                 {
                     Console.WriteLine("  now inputPos=" + m_inputPos);
@@ -216,7 +216,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startPosData.StartOffset == startOffset, () => "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(startPosData.StartOffset == startOffset, () => "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
                 }
 
                 int endOffset = m_offsetAtt.EndOffset;
@@ -227,7 +227,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endPosData.EndOffset == endOffset, () => "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(endPosData.EndOffset == endOffset, () => "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
                 }
 
                 tokenPending = true;
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent());
                             insertPending = false;
                             return true;
                         }
@@ -340,7 +340,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(InsertedTokenConsistent());
                             insertPending = false;
                             return true;
                         }
@@ -364,8 +364,8 @@ namespace Lucene.Net.Analysis
         {
             int posLen = m_posLenAtt.PositionLength;
             Position endPosData = m_positions.Get(m_outputPos + posLen);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => endPosData.EndOffset != -1);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m_offsetAtt.EndOffset == endPosData.EndOffset, () => "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
+            if (Debugging.AssertsEnabled) Debugging.Assert(endPosData.EndOffset != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(m_offsetAtt.EndOffset == endPosData.EndOffset, () => "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
             return true;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
index 0b377d1..d7ef75e 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
@@ -112,7 +112,7 @@ namespace Lucene.Net.Analysis
                 ret = currentOff;
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ret >= 0, () => "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
+            if (Debugging.AssertsEnabled) Debugging.Assert(ret >= 0, () => "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
             return ret;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
index 49bbebf..f7527ca 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis
         {
             excAtChar = charUpto;
             // You should only call this on init!:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => 0 == readSoFar);
+            if (Debugging.AssertsEnabled) Debugging.Assert(0 == readSoFar);
         }
 
         public virtual void ThrowExcNext()
@@ -91,10 +91,10 @@ namespace Lucene.Net.Analysis
             if (excAtChar != -1)
             {
                 int left = excAtChar - readSoFar;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => left != 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(left != 0);
                 read = input.Read(cbuf, off, Math.Min(realLen, left));
                 //Characters are left
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => read != 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(read != 0);
                 readSoFar += read;
             }
             else
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
index 50152f6..d6da069 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
@@ -140,7 +140,7 @@ namespace Lucene.Net.Analysis
 
         public sealed override bool IncrementToken()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), () => "IncrementToken() called while in wrong state: " + streamState);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), () => "IncrementToken() called while in wrong state: " + streamState);
             ClearAttributes();
             for (; ; )
             {
@@ -219,7 +219,7 @@ namespace Lucene.Net.Analysis
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !char.IsLowSurrogate((char)ch), () => "unpaired low surrogate: " + ch.ToString("x"));
+                if (Debugging.AssertsEnabled) Debugging.Assert(!char.IsLowSurrogate((char)ch), () => "unpaired low surrogate: " + ch.ToString("x"));
                 off++;
                 if (char.IsHighSurrogate((char)ch))
                 {
@@ -227,12 +227,12 @@ namespace Lucene.Net.Analysis
                     if (ch2 >= 0)
                     {
                         off++;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => char.IsLowSurrogate((char)ch2), () => "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(char.IsLowSurrogate((char)ch2), () => "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
                         return Character.ToCodePoint((char)ch, (char)ch2);
                     }
                     else
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "stream ends with unpaired high surrogate: " + ch.ToString("x"));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "stream ends with unpaired high surrogate: " + ch.ToString("x"));
                     }
                 }
                 return ch;
@@ -300,7 +300,7 @@ namespace Lucene.Net.Analysis
             state = runAutomaton.InitialState;
             lastOffset = off = 0;
             bufferedCodePoint = -1;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState != State.RESET, () => "Double Reset()");
+            if (Debugging.AssertsEnabled) Debugging.Assert(!enableChecks || streamState != State.RESET, () => "Double Reset()");
             streamState = State.RESET;
         }
 
@@ -312,14 +312,14 @@ namespace Lucene.Net.Analysis
                 // in some exceptional cases (e.g. TestIndexWriterExceptions) a test can prematurely close()
                 // these tests should disable this check, by default we check the normal workflow.
                 // TODO: investigate the CachingTokenFilter "double-close"... for now we ignore this
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.END || streamState == State.CLOSE, () => "Dispose() called in wrong state: " + streamState);
+                if (Debugging.AssertsEnabled) Debugging.Assert(!enableChecks || streamState == State.END || streamState == State.CLOSE, () => "Dispose() called in wrong state: " + streamState);
                 streamState = State.CLOSE;
             }
         }
 
         internal override bool SetReaderTestPoint()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.CLOSE, () => "SetReader() called in wrong state: " + streamState);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!enableChecks || streamState == State.CLOSE, () => "SetReader() called in wrong state: " + streamState);
             streamState = State.SETREADER;
             return true;
         }
@@ -333,7 +333,7 @@ namespace Lucene.Net.Analysis
             // these tests should disable this check (in general you should consume the entire stream)
             try
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !enableChecks || streamState == State.INCREMENT_FALSE, () => "End() called before IncrementToken() returned false!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(!enableChecks || streamState == State.INCREMENT_FALSE, () => "End() called before IncrementToken() returned false!");
             }
             finally
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
index 486a980..e2da7b6 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
@@ -40,15 +40,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer FieldsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.FieldsConsumer(state);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(consumer != null);
             return new AssertingDocValuesConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer FieldsProducer(SegmentReadState state)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.FieldInfos.HasDocValues);
+            if (Debugging.AssertsEnabled) Debugging.Assert(state.FieldInfos.HasDocValues);
             DocValuesProducer producer = @in.FieldsProducer(state);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => producer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
 
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     count++;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddNumericField(field, values);
             }
@@ -80,10 +80,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (BytesRef b in values)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b == null || b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(b == null || b.IsValid());
                     count++;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddBinaryField(field, values);
             }
@@ -94,25 +94,25 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b != null);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(b != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(b.IsValid());
                     if (valueCount > 0)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => b.CompareTo(lastValue) > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount <= maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(valueCount <= maxDoc);
 
                 FixedBitSet seenOrds = new FixedBitSet(valueCount);
 
                 int count = 0;
                 foreach (long? v in docToOrd)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(v != null);
                     int ord = (int)v.Value;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= -1 && ord < valueCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ord >= -1 && ord < valueCount);
                     if (ord >= 0)
                     {
                         seenOrds.Set(ord);
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Asserting
                     count++;
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(seenOrds.Cardinality() == valueCount);
                 CheckIterator(values.GetEnumerator(), valueCount, false);
                 CheckIterator(docToOrd.GetEnumerator(), maxDoc, false);
                 @in.AddSortedField(field, values, docToOrd);
@@ -133,11 +133,11 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b != null);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => b.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(b != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(b.IsValid());
                     if (valueCount > 0)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => b.CompareTo(lastValue) > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
@@ -150,9 +150,9 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     foreach (long? v in docToOrdCount)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(v != null);
                         int count = (int)v.Value;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => count >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(count >= 0);
                         docCount++;
                         ordCount += count;
 
@@ -161,18 +161,18 @@ namespace Lucene.Net.Codecs.Asserting
                         {
                             ordIterator.MoveNext();
                             long? o = ordIterator.Current;
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => o != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(o != null);
                             long ord = o.Value;
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord > lastOrd, () => "ord=" + ord + ",lastOrd=" + lastOrd);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(ord >= 0 && ord < valueCount);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(ord > lastOrd, () => "ord=" + ord + ",lastOrd=" + lastOrd);
                             seenOrds.Set(ord);
                             lastOrd = ord;
                         }
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ordIterator.MoveNext() == false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ordIterator.MoveNext() == false);
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == maxDoc);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(docCount == maxDoc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(seenOrds.Cardinality() == valueCount);
                     CheckIterator(values.GetEnumerator(), valueCount, false);
                     CheckIterator(docToOrdCount.GetEnumerator(), maxDoc, false);
                     CheckIterator(ords.GetEnumerator(), ordCount, false);
@@ -203,10 +203,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (long? v in values)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(v != null);
                     count++;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, false);
                 @in.AddNumericField(field, values);
             }
@@ -240,9 +240,9 @@ namespace Lucene.Net.Codecs.Asserting
                 for (long i = 0; i < expectedSize; i++)
                 {
                     bool hasNext = iterator.MoveNext();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => hasNext);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(hasNext);
                     T v = iterator.Current;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => allowNull || v != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(allowNull || v != null);
 
                     // LUCENE.NET specific. removed call to Reset().
                     //try
@@ -255,7 +255,7 @@ namespace Lucene.Net.Codecs.Asserting
                     //    // ok
                     //}
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !iterator.MoveNext());
+                if (Debugging.AssertsEnabled) Debugging.Assert(!iterator.MoveNext());
                 /*try
                 {
                   //iterator.next();
@@ -285,42 +285,42 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override NumericDocValues GetNumeric(FieldInfo field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
                 NumericDocValues values = @in.GetNumeric(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(values != null);
                 return new AssertingNumericDocValues(values, maxDoc);
             }
 
             public override BinaryDocValues GetBinary(FieldInfo field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.DocValuesType == DocValuesType.BINARY);
                 BinaryDocValues values = @in.GetBinary(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(values != null);
                 return new AssertingBinaryDocValues(values, maxDoc);
             }
 
             public override SortedDocValues GetSorted(FieldInfo field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.DocValuesType == DocValuesType.SORTED);
                 SortedDocValues values = @in.GetSorted(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(values != null);
                 return new AssertingSortedDocValues(values, maxDoc);
             }
 
             public override SortedSetDocValues GetSortedSet(FieldInfo field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.DocValuesType == DocValuesType.SORTED_SET);
                 SortedSetDocValues values = @in.GetSortedSet(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => values != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(values != null);
                 return new AssertingSortedSetDocValues(values, maxDoc);
             }
 
             public override IBits GetDocsWithField(FieldInfo field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.DocValuesType != DocValuesType.NONE);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.DocValuesType != DocValuesType.NONE);
                 IBits bits = @in.GetDocsWithField(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => bits != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => bits.Length == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(bits != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(bits.Length == maxDoc);
                 return new AssertingBits(bits);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
index ea40b54..1e87622 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
@@ -32,15 +32,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer NormsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.NormsConsumer(state);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(consumer != null);
             return new AssertingNormsConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer NormsProducer(SegmentReadState state)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.FieldInfos.HasNorms);
+            if (Debugging.AssertsEnabled) Debugging.Assert(state.FieldInfos.HasNorms);
             DocValuesProducer producer = @in.NormsProducer(state);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => producer != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
     }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
index 69e981f..f0e3fc2 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override IEnumerator<string> GetEnumerator()
             {
                 IEnumerator<string> iterator = @in.GetEnumerator();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => iterator != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(iterator != null);
                 return iterator;
             }
 
@@ -105,7 +105,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override TermsConsumer AddField(FieldInfo field)
             {
                 TermsConsumer consumer = @in.AddField(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => consumer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(consumer != null);
                 return new AssertingTermsConsumer(consumer, field);
             }
 
@@ -144,28 +144,28 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override PostingsConsumer StartTerm(BytesRef text)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.START;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
                 lastTerm = BytesRef.DeepCopyOf(text);
                 return lastPostingsConsumer = new AssertingPostingsConsumer(@in.StartTerm(text), fieldInfo, visitedDocs);
             }
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == TermsConsumerState.START);
                 state = TermsConsumerState.INITIAL;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => text.Equals(lastTerm));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0); // otherwise, this method should not be called.
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq == lastPostingsConsumer.docFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(text.Equals(lastTerm));
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq > 0); // otherwise, this method should not be called.
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq == lastPostingsConsumer.docFreq);
                 sumDocFreq += stats.DocFreq;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.TotalTermFreq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(stats.TotalTermFreq == -1);
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
                     sumTotalTermFreq += stats.TotalTermFreq;
                 }
                 @in.FinishTerm(text, stats);
@@ -173,20 +173,20 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(long sumTotalTermFreq, long sumDocFreq, int docCount)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.FINISHED;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount >= 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == visitedDocs.Cardinality());
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sumDocFreq >= docCount);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => sumDocFreq == this.sumDocFreq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docCount >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docCount == visitedDocs.Cardinality());
+                if (Debugging.AssertsEnabled) Debugging.Assert(sumDocFreq >= docCount);
+                if (Debugging.AssertsEnabled) Debugging.Assert(sumDocFreq == this.sumDocFreq);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(sumTotalTermFreq == -1);
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq >= sumDocFreq);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sumTotalTermFreq == this.sumTotalTermFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(sumTotalTermFreq >= sumDocFreq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(sumTotalTermFreq == this.sumTotalTermFreq);
                 }
                 @in.Finish(sumTotalTermFreq, sumDocFreq, docCount);
             }
@@ -222,17 +222,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDoc(int docID, int freq)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.INITIAL);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == PostingsConsumerState.INITIAL);
                 state = PostingsConsumerState.START;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(freq == -1);
                     this.freq = 0; // we don't expect any positions here
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                     this.freq = freq;
                     totalTermFreq += freq;
                 }
@@ -246,41 +246,41 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.START);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount < freq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == PostingsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(positionCount < freq);
                 positionCount++;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
+                if (Debugging.AssertsEnabled) Debugging.Assert(position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
                 lastPosition = position;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= 0);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset >= lastStartOffset);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(startOffset >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(startOffset >= lastStartOffset);
                     lastStartOffset = startOffset;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset >= startOffset);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(endOffset >= startOffset);
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(startOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(endOffset == -1);
                 }
                 if (payload != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo.HasPayloads);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(fieldInfo.HasPayloads);
                 }
                 @in.AddPosition(position, payload, startOffset, endOffset);
             }
 
             public override void FinishDoc()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == PostingsConsumerState.START);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == PostingsConsumerState.START);
                 state = PostingsConsumerState.INITIAL;
                 if (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == 0); // we should not have fed any positions!
+                    if (Debugging.AssertsEnabled) Debugging.Assert(positionCount == 0); // we should not have fed any positions!
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == freq);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(positionCount == freq);
                 }
                 @in.FinishDoc();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
index d4d9d76..fa3514e 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void VisitDocument(int n, StoredFieldVisitor visitor)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => n >= 0 && n < maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(n >= 0 && n < maxDoc);
                 @in.VisitDocument(n, visitor);
             }
 
@@ -100,9 +100,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numStoredFields)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus != Status.STARTED);
                 @in.StartDocument(numStoredFields);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount == 0);
                 fieldCount = numStoredFields;
                 numWritten++;
                 docStatus = Status.STARTED;
@@ -110,17 +110,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount == 0);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void WriteField(FieldInfo info, IIndexableField field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
                 @in.WriteField(info, field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount > 0);
                 fieldCount--;
             }
 
@@ -131,10 +131,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
                 @in.Finish(fis, numDocs);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs == numWritten);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numDocs == numWritten);
             }
 
             protected override void Dispose(bool disposing)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
index b7ce230..dd538b9 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
@@ -103,8 +103,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numVectorFields)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus != Status.STARTED);
                 @in.StartDocument(numVectorFields);
                 docStatus = Status.STARTED;
                 fieldCount = numVectorFields;
@@ -113,17 +113,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus != Status.STARTED);
                 @in.StartField(info, numTerms, positions, offsets, payloads);
                 fieldStatus = Status.STARTED;
                 termCount = numTerms;
@@ -132,8 +132,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishField()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus == Status.STARTED);
                 @in.FinishField();
                 fieldStatus = Status.FINISHED;
                 --fieldCount;
@@ -141,9 +141,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartTerm(BytesRef term, int freq)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termStatus != Status.STARTED);
                 @in.StartTerm(term, freq);
                 termStatus = Status.STARTED;
                 positionCount = hasPositions ? freq : 0;
@@ -151,10 +151,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishTerm()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount == 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(positionCount == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termStatus == Status.STARTED);
                 @in.FinishTerm();
                 termStatus = Status.FINISHED;
                 --termCount;
@@ -162,9 +162,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus == Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus == Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termStatus == Status.STARTED);
                 @in.AddPosition(position, startOffset, endOffset, payload);
                 --positionCount;
             }
@@ -176,10 +176,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docCount == numDocs);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldStatus != Status.STARTED);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => termStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docCount == numDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                if (Debugging.AssertsEnabled) Debugging.Assert(fieldStatus != Status.STARTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(termStatus != Status.STARTED);
                 @in.Finish(fis, numDocs);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
index ae218dd..f1eef1b 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
         {
             public override void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => offset + length <= originalLength);
+                if (Debugging.AssertsEnabled) Debugging.Assert(offset + length <= originalLength);
                 if (bytes.Bytes.Length < originalLength)
                 {
                     bytes.Bytes = new byte[ArrayUtil.Oversize(originalLength, 1)];
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
index 8a461be..0538bdc 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (fi.IsIndexed)
                     {
                         bits |= IS_INDEXED;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
                         if (fi.IndexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= OMIT_TERM_FREQ_AND_POSITIONS;
@@ -103,7 +103,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         // only in RW case
                         output.WriteByte((byte)(sbyte)(fi.NormType == Index.DocValuesType.NONE ? 0 : 1));
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.Attributes == null); // not used or supported
+                    if (Debugging.AssertsEnabled) Debugging.Assert(fi.Attributes == null); // not used or supported
                 }
                 success = true;
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
index a849aeb..25bdea9 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
@@ -81,7 +81,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override TermsConsumer AddField(FieldInfo field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Number != -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field.Number != -1);
             if (field.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0)
             {
                 throw new NotSupportedException("this codec cannot index offsets");
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                     lastDocID = docID;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => docID < outerInstance.outerInstance.totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(docID < outerInstance.outerInstance.totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
 
                     if (outerInstance.omitTF)
                     {
@@ -188,9 +188,9 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                 public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.outerInstance.proxOut != null);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.outerInstance.proxOut != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(startOffset == -1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(endOffset == -1);
                     //System.out.println("      w pos=" + position + " payl=" + payload);
                     int delta = position - lastPosition;
                     lastPosition = position;
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
index 9cd2cde..0ff6703 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddNumericField(FieldInfo field, IEnumerable<long?> values)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Number > lastFieldNumber, () => "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field.Number > lastFieldNumber, () => "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
             foreach (var n in values)
             {
                 if (((sbyte)(byte)(long)n) < sbyte.MinValue || ((sbyte)(byte)(long)n) > sbyte.MaxValue)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
index 807b279..03f3a3d 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public PreFlexRWStoredFieldsWriter(Directory directory, string segment, IOContext context)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => directory != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(directory != null);
             this.directory = directory;
             this.segment = segment;
 
@@ -188,7 +188,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         fieldsStream.WriteInt64(J2N.BitConversion.DoubleToInt64Bits(field.GetDoubleValue().Value));
                         break;
                     default:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(false);
                         break;
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
index 1c42cd5..e08d332 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
             lastFieldName = info.Name;
             if (payloads)
             {
@@ -98,7 +98,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
             tvf.WriteByte((byte)bits);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldCount <= numVectorFields);
+            if (Debugging.AssertsEnabled) Debugging.Assert(fieldCount <= numVectorFields);
             if (fieldCount == numVectorFields)
             {
                 // last field of the document
@@ -148,7 +148,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(payload == null);
             if (positions && offsets)
             {
                 // write position delta
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
index 61d3b9e..8e33659 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
@@ -135,7 +135,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 output.WriteInt32(indexInterval); // write indexInterval
                 output.WriteInt32(skipInterval); // write skipInterval
                 output.WriteInt32(maxSkipLevels); // write maxSkipLevels
-                if (Debugging.AssertsEnabled) Debugging.Assert(InitUTF16Results);
+                if (Debugging.AssertsEnabled) Debugging.Assert(InitUTF16Results());
                 success = true;
             }
             finally
@@ -202,10 +202,10 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
 
             scratchBytes.CopyBytes(term);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastTerm.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lastTerm.Offset == 0);
             UnicodeUtil.UTF8toUTF16(lastTerm.Bytes, 0, lastTerm.Length, utf16Result1);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchBytes.Offset == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(scratchBytes.Offset == 0);
             UnicodeUtil.UTF8toUTF16(scratchBytes.Bytes, 0, scratchBytes.Length, utf16Result2);
 
             int len;
@@ -243,10 +243,10 @@ namespace Lucene.Net.Codecs.Lucene3x
         /// </summary>
         public void Add(int fieldNumber, BytesRef term, TermInfo ti)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), () => "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
+            if (Debugging.AssertsEnabled) Debugging.Assert(CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), () => "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ti.FreqPointer >= lastTi.FreqPointer, () => "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ti.ProxPointer >= lastTi.ProxPointer, () => "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
+            if (Debugging.AssertsEnabled) Debugging.Assert(ti.FreqPointer >= lastTi.FreqPointer, () => "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
+            if (Debugging.AssertsEnabled) Debugging.Assert(ti.ProxPointer >= lastTi.ProxPointer, () => "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
 
             if (!isIndex && size % indexInterval == 0)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
index 62d6dc1..ed4709d 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
@@ -333,7 +333,7 @@ namespace Lucene.Net.Codecs.Lucene40
             index.WriteVInt64(maxAddress);
 
             int maxDoc = state.SegmentInfo.DocCount;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => maxDoc != int.MaxValue); // unsupported by the 4.0 impl
+            if (Debugging.AssertsEnabled) Debugging.Assert(maxDoc != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -346,7 +346,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
             }
             // write sentinel
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentPosition == maxAddress);
+            if (Debugging.AssertsEnabled) Debugging.Assert(currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
         }
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             /* ordinals */
             int valueCount = dictionary.Count;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount > 0);
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
@@ -439,7 +439,7 @@ namespace Lucene.Net.Codecs.Lucene40
         // the little vint encoding used for var-deref
         private static void WriteVInt16(IndexOutput o, int i)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => i >= 0 && i <= short.MaxValue);
+            if (Debugging.AssertsEnabled) Debugging.Assert(i >= 0 && i <= short.MaxValue);
             if (i < 128)
             {
                 o.WriteByte((byte)(sbyte)i);
@@ -545,7 +545,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount > 0);
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
@@ -578,7 +578,7 @@ namespace Lucene.Net.Codecs.Lucene40
             long maxAddress = data.GetFilePointer() - startPos;
             index.WriteInt64(maxAddress);
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount != int.MaxValue); // unsupported by the 4.0 impl
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, valueCount + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -588,14 +588,14 @@ namespace Lucene.Net.Codecs.Lucene40
                 currentPosition += v.Length;
             }
             // write sentinel
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentPosition == maxAddress);
+            if (Debugging.AssertsEnabled) Debugging.Assert(currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
 
             /* ordinals */
 
             int maxDoc = state.SegmentInfo.DocCount;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount > 0);
             PackedInt32s.Writer ords = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
index d4eb855..3a13fac 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene40FieldInfosFormat.IS_INDEXED;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene40FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     // pack the DV types in one byte
                     byte dv = DocValuesByte(fi.DocValuesType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_DV_TYPE_KEY));
                     byte nrm = DocValuesByte(fi.NormType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_NORM_TYPE_KEY));
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert((dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
@@ -113,12 +113,12 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             if (type == DocValuesType.NONE)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => legacyTypeAtt == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(legacyTypeAtt == null);
                 return 0;
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => legacyTypeAtt != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(legacyTypeAtt != null);
                 //return (sbyte)LegacyDocValuesType.ordinalLookup[legacyTypeAtt];
                 return (byte)legacyTypeAtt.ToLegacyDocValuesType();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
index d5b8e24..8124e65 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
@@ -208,7 +208,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 skipListWriter.BufferSkip(df);
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID < totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + totalNumDocs);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID < totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + totalNumDocs);
 
             lastDocID = docID;
             if (indexOptions == IndexOptions.DOCS_ONLY)
@@ -234,12 +234,12 @@ namespace Lucene.Net.Codecs.Lucene40
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
             //if (DEBUG) System.out.println("SPW:     addPos pos=" + position + " payload=" + (payload == null ? "null" : (payload.Length + " bytes")) + " proxFP=" + proxOut.getFilePointer());
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, () => "invalid indexOptions: " + indexOptions);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => proxOut != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, () => "invalid indexOptions: " + indexOptions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(proxOut != null);
 
             int delta = position - lastPosition;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
+            if (Debugging.AssertsEnabled) Debugging.Assert(delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
 
             lastPosition = position;
 
@@ -271,7 +271,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 // and the numbers aren't that much smaller anyways.
                 int offsetDelta = startOffset - lastOffset;
                 int offsetLength = endOffset - startOffset;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => offsetDelta >= 0 && offsetLength >= 0, () => "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
+                if (Debugging.AssertsEnabled) Debugging.Assert(offsetDelta >= 0 && offsetLength >= 0, () => "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
                 if (offsetLength != lastOffsetLength)
                 {
                     proxOut.WriteVInt32(offsetDelta << 1 | 1);
@@ -308,11 +308,11 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             StandardTermState state_ = (StandardTermState)state;
             // if (DEBUG) System.out.println("SPW: finishTerm seg=" + segment + " freqStart=" + freqStart);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.DocFreq > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(state_.DocFreq > 0);
 
             // TODO: wasteful we are counting this (counting # docs
             // for this term) in two places?
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.DocFreq == df);
+            if (Debugging.AssertsEnabled) Debugging.Assert(state_.DocFreq == df);
             state_.FreqStart = freqStart;
             state_.ProxStart = proxStart;
             if (df >= skipMinimum)
@@ -337,7 +337,7 @@ namespace Lucene.Net.Codecs.Lucene40
             @out.WriteVInt64(state_.FreqStart - lastState.FreqStart);
             if (state_.SkipOffset != -1)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state_.SkipOffset > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state_.SkipOffset > 0);
                 @out.WriteVInt64(state_.SkipOffset);
             }
             if (indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
index d6ffba9..5b902a2 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
@@ -67,8 +67,8 @@ namespace Lucene.Net.Codecs.Lucene40
         /// </summary>
         public virtual void SetSkipData(int doc, bool storePayloads, int payloadLength, bool storeOffsets, int offsetLength)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => storePayloads || payloadLength == -1);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => storeOffsets || offsetLength == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(storePayloads || payloadLength == -1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(storeOffsets || offsetLength == -1);
             this.curDoc = doc;
             this.curStorePayloads = storePayloads;
             this.curPayloadLength = payloadLength;
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
             if (curStorePayloads || curStoreOffsets)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
+                if (Debugging.AssertsEnabled) Debugging.Assert(curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
 
                 if (curPayloadLength == lastSkipPayloadLength[level] && curOffsetLength == lastSkipOffsetLength[level])
                 {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
index 6c5c200..fde6cbf 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
@@ -125,7 +125,7 @@ namespace Lucene.Net.Codecs.Lucene42
 
                     ++count;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => count == maxDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(count == maxDoc);
             }
 
             if (uniqueValues != null)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
index 11287be..f47d6c5 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene42FieldInfosFormat.IS_INDEXED;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene42FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     // pack the DV types in one byte
                     var dv = DocValuesByte(fi.DocValuesType);
                     var nrm = DocValuesByte(fi.NormType);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert((dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
index 8734489..e484e59 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -107,7 +107,7 @@ namespace Lucene.Net.Codecs.MockIntBlock
                     {
                         buffer[0] = input.ReadVInt32();
                         int count = buffer[0] <= 3 ? baseBlockSize - 1 : 2 * baseBlockSize - 1;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => buffer.Length >= count, () => "buffer.length=" + buffer.Length + " count=" + count);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(buffer.Length >= count, () => "buffer.length=" + buffer.Length + " count=" + count);
                         for (int i = 0; i < count; i++)
                         {
                             buffer[i + 1] = input.ReadVInt32();
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
index 8481e0d..b4f7811 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.MockRandom
             private static string GetExtension(string fileName)
             {
                 int idx = fileName.IndexOf('.');
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => idx != -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(idx != -1);
                 return fileName.Substring(idx);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
index ba4029e..f39a807 100644
--- a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
@@ -290,8 +290,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq == current.docs.Count);
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq == current.docs.Count);
                 current.totalTermFreq = stats.TotalTermFreq;
                 field.termToDocs[current.term] = current;
             }
@@ -324,8 +324,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => startOffset == -1);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => endOffset == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(startOffset == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(endOffset == -1);
                 current.positions[posUpto] = position;
                 if (payload != null && payload.Length > 0)
                 {
@@ -341,7 +341,7 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishDoc()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => posUpto == current.positions.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(posUpto == current.positions.Length);
             }
         }
 
diff --git a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
index c545d60..9342369 100644
--- a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             liveDocs = new Bits.MatchNoBits(@in.MaxDoc);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == 0 || HasDeletions);
+            if (Debugging.AssertsEnabled) Debugging.Assert(MaxDoc == 0 || HasDeletions);
         }
 
         public override IBits LiveDocs => liveDocs;
diff --git a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
index 077b270..f36ddb8 100644
--- a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public override IEnumerator<string> GetEnumerator()
         {
             IEnumerator<string> iterator = base.GetEnumerator();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => iterator != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(iterator != null);
             return iterator;
         }
 
@@ -59,8 +59,8 @@ namespace Lucene.Net.Index
         public override TermsEnum Intersect(CompiledAutomaton automaton, BytesRef bytes)
         {
             TermsEnum termsEnum = m_input.Intersect(automaton, bytes);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => bytes == null || bytes.IsValid());
+            if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(bytes == null || bytes.IsValid());
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
 
@@ -73,7 +73,7 @@ namespace Lucene.Net.Index
                 reuse = ((AssertingAtomicReader.AssertingTermsEnum)reuse).m_input;
             }
             TermsEnum termsEnum = base.GetIterator(reuse);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => termsEnum != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(termsEnum != null);
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
     }
@@ -102,7 +102,7 @@ namespace Lucene.Net.Index
             try
             {
                 int docid = @in.DocID;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docid == -1, () => @in.GetType() + ": invalid initial doc id: " + docid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docid == -1, () => @in.GetType() + ": invalid initial doc id: " + docid);
             }
             catch (NotSupportedException /*e*/)
             {
@@ -116,9 +116,9 @@ namespace Lucene.Net.Index
 
         public override int NextDoc()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
+            if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
             int nextDoc = base.NextDoc();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextDoc > doc, () => "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
+            if (Debugging.AssertsEnabled) Debugging.Assert(nextDoc > doc, () => "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
             if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -127,16 +127,16 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == nextDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(base.DocID == nextDoc);
             return doc = nextDoc;
         }
 
         public override int Advance(int target)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+            if (Debugging.AssertsEnabled) Debugging.Assert(target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
             int advanced = base.Advance(target);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
+            if (Debugging.AssertsEnabled) Debugging.Assert(advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
             if (advanced == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -145,7 +145,7 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == advanced);
+            if (Debugging.AssertsEnabled) Debugging.Assert(base.DocID == advanced);
             return doc = advanced;
         }
 
@@ -153,7 +153,7 @@ namespace Lucene.Net.Index
         {
             get
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                 return doc;
             }
         }
@@ -162,10 +162,10 @@ namespace Lucene.Net.Index
         {
             get
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                 int freq = base.Freq;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                 return freq;
             }
         }
@@ -186,7 +186,7 @@ namespace Lucene.Net.Index
 
         public override long Get(int docID)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0 && docID < maxDoc);
             return @in.Get(docID);
         }
     }
@@ -206,10 +206,10 @@ namespace Lucene.Net.Index
 
         public override void Get(int docID, BytesRef result)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
             @in.Get(docID, result);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
         }
     }
 
@@ -226,23 +226,23 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount >= 0 && valueCount <= maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount >= 0 && valueCount <= maxDoc);
         }
 
         public override int GetOrd(int docID)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0 && docID < maxDoc);
             int ord = @in.GetOrd(docID);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= -1 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(ord >= -1 && ord < valueCount);
             return ord;
         }
 
         public override void LookupOrd(int ord, BytesRef result)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(ord >= 0 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
             @in.LookupOrd(ord, result);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
         }
 
         public override int ValueCount
@@ -250,25 +250,25 @@ namespace Lucene.Net.Index
             get
             {
                 int valueCount = @in.ValueCount;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount == this.valueCount); // should not change
+                if (Debugging.AssertsEnabled) Debugging.Assert(valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override void Get(int docID, BytesRef result)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0 && docID < maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
             @in.Get(docID, result);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
         }
 
         public override int LookupTerm(BytesRef key)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid());
             int result = @in.LookupTerm(key);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => result < valueCount);
-            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid());
             return result;
         }
     }
@@ -287,32 +287,32 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(valueCount >= 0);
         }
 
         public override long NextOrd()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lastOrd != NO_MORE_ORDS);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lastOrd != NO_MORE_ORDS);
             long ord = @in.NextOrd();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord < valueCount);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord == NO_MORE_ORDS || ord > lastOrd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(ord == NO_MORE_ORDS || ord > lastOrd);
             lastOrd = ord;
             return ord;
         }
 
         public override void SetDocument(int docID)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => docID >= 0 && docID < maxDoc, () => "docid=" + docID + ",maxDoc=" + maxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(docID >= 0 && docID < maxDoc, () => "docid=" + docID + ",maxDoc=" + maxDoc);
             @in.SetDocument(docID);
             lastOrd = -2;
         }
 
         public override void LookupOrd(long ord, BytesRef result)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => ord >= 0 && ord < valueCount);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(ord >= 0 && ord < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
             @in.LookupOrd(ord, result);
-            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
         }
 
         public override long ValueCount
@@ -320,17 +320,17 @@ namespace Lucene.Net.Index
             get
             {
                 long valueCount = @in.ValueCount;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => valueCount == this.valueCount); // should not change
+                if (Debugging.AssertsEnabled) Debugging.Assert(valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override long LookupTerm(BytesRef key)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid());
             long result = @in.LookupTerm(key);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => result < valueCount);
-            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid);
+            if (Debugging.AssertsEnabled) Debugging.Assert(result < valueCount);
+            if (Debugging.AssertsEnabled) Debugging.Assert(key.IsValid());
             return result;
         }
     }
@@ -348,7 +348,7 @@ namespace Lucene.Net.Index
 
         public virtual bool Get(int index)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => index >= 0 && index < Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(index >= 0 && index < Length);
             return @in.Get(index);
         }
 
@@ -365,10 +365,10 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             // check some basic reader sanity
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.MaxDoc >= 0);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.NumDocs <= @in.MaxDoc);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(@in.MaxDoc >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(@in.NumDocs <= @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(@in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(!@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
         }
 
         public override Fields Fields
@@ -409,7 +409,7 @@ namespace Lucene.Net.Index
 
             public override DocsEnum Docs(IBits liveDocs, DocsEnum reuse, DocsFlags flags)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Docs(...) called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "Docs(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -423,7 +423,7 @@ namespace Lucene.Net.Index
 
             public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "DocsAndPositions(...) called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "DocsAndPositions(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -439,7 +439,7 @@ namespace Lucene.Net.Index
             // someone should not call next() after it returns null!!!!
             public override BytesRef Next()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.INITIAL || state == State.POSITIONED, () => "Next() called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == State.INITIAL || state == State.POSITIONED, () => "Next() called on unpositioned TermsEnum");
                 BytesRef result = base.Next();
                 if (result == null)
                 {
@@ -447,7 +447,7 @@ namespace Lucene.Net.Index
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(result.IsValid());
                     state = State.POSITIONED;
                 }
                 return result;
@@ -457,7 +457,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Ord called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "Ord called on unpositioned TermsEnum");
                     return base.Ord;
                 }
             }
@@ -466,7 +466,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "DocFreq called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "DocFreq called on unpositioned TermsEnum");
                     return base.DocFreq;
                 }
             }
@@ -475,7 +475,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "TotalTermFreq called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "TotalTermFreq called on unpositioned TermsEnum");
                     return base.TotalTermFreq;
                 }
             }
@@ -484,9 +484,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "Term called on unpositioned TermsEnum");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "Term called on unpositioned TermsEnum");
                     BytesRef ret = base.Term;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ret == null || ret.IsValid());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ret == null || ret.IsValid());
                     return ret;
                 }
             }
@@ -499,7 +499,7 @@ namespace Lucene.Net.Index
 
             public override SeekStatus SeekCeil(BytesRef term)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid());
                 SeekStatus result = base.SeekCeil(term);
                 if (result == SeekStatus.END)
                 {
@@ -514,7 +514,7 @@ namespace Lucene.Net.Index
 
             public override bool SeekExact(BytesRef text)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(text.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(text.IsValid());
                 if (base.SeekExact(text))
                 {
                     state = State.POSITIONED;
@@ -529,13 +529,13 @@ namespace Lucene.Net.Index
 
             public override TermState GetTermState()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state == State.POSITIONED, () => "GetTermState() called on unpositioned TermsEnum");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state == State.POSITIONED, () => "GetTermState() called on unpositioned TermsEnum");
                 return base.GetTermState();
             }
 
             public override void SeekExact(BytesRef term, TermState state)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(term.IsValid());
                 base.SeekExact(term, state);
                 this.state = State.POSITIONED;
             }
@@ -556,15 +556,15 @@ namespace Lucene.Net.Index
                 : base(@in)
             {
                 int docid = @in.DocID;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docid == -1, () => "invalid initial doc id: " + docid);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docid == -1, () => "invalid initial doc id: " + docid);
                 doc = -1;
             }
 
             public override int NextDoc()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
                 int nextDoc = base.NextDoc();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => nextDoc > doc, () => "backwards nextDoc from " + doc + " to " + nextDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(nextDoc > doc, () => "backwards nextDoc from " + doc + " to " + nextDoc);
                 positionCount = 0;
                 if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -576,16 +576,16 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == nextDoc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(base.DocID == nextDoc);
                 return doc = nextDoc;
             }
 
             public override int Advance(int target)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
                 int advanced = base.Advance(target);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
+                if (Debugging.AssertsEnabled) Debugging.Assert(advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
                 positionCount = 0;
                 if (advanced == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -597,7 +597,7 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => base.DocID == advanced);
+                if (Debugging.AssertsEnabled) Debugging.Assert(base.DocID == advanced);
                 return doc = advanced;
             }
 
@@ -605,7 +605,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                     return doc;
                 }
             }
@@ -614,21 +614,21 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                     int freq = base.Freq;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => freq > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(freq > 0);
                     return freq;
                 }
             }
 
             public override int NextPosition()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "NextPosition() called before NextDoc()/Advance()");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextPosition() called after NO_MORE_DOCS");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount < positionMax, () => "NextPosition() called more than Freq times!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "NextPosition() called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "NextPosition() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(positionCount < positionMax, () => "NextPosition() called more than Freq times!");
                 int position = base.NextPosition();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => position >= 0 || position == -1, () => "invalid position: " + position);
+                if (Debugging.AssertsEnabled) Debugging.Assert(position >= 0 || position == -1, () => "invalid position: " + position);
                 positionCount++;
                 return position;
             }
@@ -637,9 +637,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "StartOffset called before NextDoc()/Advance()");
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "StartOffset called after NO_MORE_DOCS");
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "StartOffset called before NextPosition()!");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "StartOffset called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "StartOffset called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(positionCount > 0, () => "StartOffset called before NextPosition()!");
                     return base.StartOffset;
                 }
             }
@@ -648,20 +648,20 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "EndOffset called before NextDoc()/Advance()");
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "EndOffset called after NO_MORE_DOCS");
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "EndOffset called before NextPosition()!");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "EndOffset called before NextDoc()/Advance()");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "EndOffset called after NO_MORE_DOCS");
+                    if (Debugging.AssertsEnabled) Debugging.Assert(positionCount > 0, () => "EndOffset called before NextPosition()!");
                     return base.EndOffset;
                 }
             }
 
             public override BytesRef GetPayload()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.START, () => "GetPayload() called before NextDoc()/Advance()");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "GetPayload() called after NO_MORE_DOCS");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => positionCount > 0, () => "GetPayload() called before NextPosition()!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.START, () => "GetPayload() called before NextDoc()/Advance()");
+                if (Debugging.AssertsEnabled) Debugging.Assert(state != DocsEnumState.FINISHED, () => "GetPayload() called after NO_MORE_DOCS");
+                if (Debugging.AssertsEnabled) Debugging.Assert(positionCount > 0, () => "GetPayload() called before NextPosition()!");
                 BytesRef payload = base.GetPayload();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => payload == null || payload.IsValid() && payload.Length > 0, () => "GetPayload() returned payload with invalid length!");
+                if (Debugging.AssertsEnabled) Debugging.Assert(payload == null || payload.IsValid() && payload.Length > 0, () => "GetPayload() returned payload with invalid length!");
                 return payload;
             }
         }
@@ -681,13 +681,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.DocValuesType == DocValuesType.NUMERIC);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
                 return null;
             }
         }
@@ -698,13 +698,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.DocValuesType == DocValuesType.BINARY);
                 return new AssertingBinaryDocValues(dv, MaxDoc);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.BINARY);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.DocValuesType != DocValuesType.BINARY);
                 return null;
             }
         }
@@ -715,13 +715,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.DocValuesType == DocValuesType.SORTED);
                 return new AssertingSortedDocValues(dv, MaxDoc);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.DocValuesType != DocValuesType.SORTED);
                 return null;
             }
         }
@@ -732,13 +732,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.DocValuesType == DocValuesType.SORTED_SET);
                 return new AssertingSortedSetDocValues(dv, MaxDoc);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
                 return null;
             }
         }
@@ -749,13 +749,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.HasNorms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.HasNorms);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.HasNorms == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.HasNorms == false);
                 return null;
             }
         }
@@ -769,13 +769,13 @@ namespace Lucene.Net.Index
                 IBits liveDocs = base.LiveDocs;
                 if (liveDocs != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == liveDocs.Length);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(MaxDoc == liveDocs.Length);
                     liveDocs = new AssertingBits(liveDocs);
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == NumDocs);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !HasDeletions);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(MaxDoc == NumDocs);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!HasDeletions);
                 }
                 return liveDocs;
             }
@@ -787,14 +787,14 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (docsWithField != null)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi != null);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi.HasDocValues);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxDoc == docsWithField.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi.HasDocValues);
+                if (Debugging.AssertsEnabled) Debugging.Assert(MaxDoc == docsWithField.Length);
                 docsWithField = new AssertingBits(docsWithField);
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fi == null || fi.HasDocValues == false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fi == null || fi.HasDocValues == false);
             }
             return docsWithField;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
index e0ab0ac..4e65680 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader))).GetNumericDocValues("dv");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                     }
@@ -159,7 +159,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv");
                         Assert.AreEqual((long)J2N.BitConversion.SingleToInt32Bits(5.7f), dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - cast required because types don't match (xUnit checks this)
                     }
@@ -201,7 +201,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv2");
@@ -248,7 +248,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv1");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef(longTerm), scratch);
@@ -297,7 +297,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         BinaryDocValues dv2 = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv2");
@@ -346,7 +346,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv1");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -399,7 +399,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv2");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -438,7 +438,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(1L, dv.Get(0)); // LUCENENET specific - 1L required because types don't match (xUnit checks this)
                     Assert.AreEqual(2L, dv.Get(1)); // LUCENENET specific - 2L required because types don't match (xUnit checks this)
@@ -473,7 +473,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     for (int i = 0; i < 2; i++)
                     {
@@ -517,7 +517,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(long.MinValue, dv.Get(0));
                     Assert.AreEqual(long.MaxValue, dv.Get(1));
@@ -549,7 +549,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(-8841491950446638677L, dv.Get(0));
                     Assert.AreEqual(9062230939892376225L, dv.Get(1));
@@ -591,7 +591,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -627,7 +627,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     for (int i = 0; i < 2; i++)
@@ -684,7 +684,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                         dv.LookupOrd(dv.GetOrd(hits.ScoreDocs[i].Doc), scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -717,7 +717,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -755,7 +755,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount);
                     BytesRef scratch = new BytesRef();
@@ -797,7 +797,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount); // 2 ords
                     BytesRef scratch = new BytesRef();
@@ -894,7 +894,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -925,7 +925,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -1045,7 +1045,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     Assert.AreEqual(0, dv.GetOrd(0));
@@ -1080,7 +1080,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1114,7 +1114,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1146,7 +1146,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1174,7 +1174,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1205,7 +1205,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1239,7 +1239,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1277,7 +1277,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1494,7 +1494,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 256);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -1580,7 +1580,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 256);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -2649,13 +2649,13 @@ namespace Lucene.Net.Index
                             }
                             for (int j = 0; j < stringValues.Length; j++)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => docValues != null);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(docValues != null);
                                 long ord = docValues.NextOrd();
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(ord != SortedSetDocValues.NO_MORE_ORDS);
                                 docValues.LookupOrd(ord, scratch);
                                 Assert.AreEqual(stringValues[j], scratch.Utf8ToString());
                             }
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
                         }
                     }
                 } // ir.Dispose();
diff --git a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
index 7498cfe..45e2392 100644
--- a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
@@ -239,7 +239,7 @@ namespace Lucene.Net.Index
                     posUpto = freq;
                     return 0;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => posUpto < freq);
+                if (Debugging.AssertsEnabled) Debugging.Assert(posUpto < freq);
 
                 if (posUpto == 0 && random.NextBoolean())
                 {
diff --git a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
index 528d0c9..f4e0675 100644
--- a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
+++ b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
@@ -106,7 +106,7 @@ namespace Lucene.Net.Index
                 {
                     foreach (SegmentCommitInfo info in merge.Segments)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => segmentsToMerge.ContainsKey(info));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(segmentsToMerge.ContainsKey(info));
                     }
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
index 2b0436f..74da42e 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
@@ -92,7 +92,7 @@ namespace Lucene.Net.Index
                 }
                 previousMappings[name] = codec;
                 // Safety:
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => previousMappings.Count < 10000, () => "test went insane");
+                if (Debugging.AssertsEnabled) Debugging.Assert(previousMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
@@ -115,7 +115,7 @@ namespace Lucene.Net.Index
                 }
                 previousDVMappings[name] = codec;
                 // Safety:
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => previousDVMappings.Count < 10000, () => "test went insane");
+                if (Debugging.AssertsEnabled) Debugging.Assert(previousDVMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
diff --git a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
index 52faf55..fc82ddb 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public RandomDocumentsWriterPerThreadPool(int maxNumPerThreads, Random random)
             : base(maxNumPerThreads)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => MaxThreadStates >= 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(MaxThreadStates >= 1);
             states = new ThreadState[maxNumPerThreads];
             this.random = new Random(random.Next());
             this.maxRetry = 1 + random.Next(10);
@@ -56,14 +56,14 @@ namespace Lucene.Net.Index
                     }
                 }
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => NumThreadStatesActive > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(NumThreadStatesActive > 0);
             for (int i = 0; i < maxRetry; i++)
             {
                 int ord = random.Next(NumThreadStatesActive);
                 lock (this)
                 {
                     threadState = states[ord];
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => threadState != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(threadState != null);
                 }
 
                 if (threadState.TryLock())
@@ -94,7 +94,7 @@ namespace Lucene.Net.Index
                 }
                 // if no new state is available lock the random one
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => threadState != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(threadState != null);
             threadState.@Lock();
             return threadState;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
index 91a368e..1506033 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
@@ -440,7 +440,7 @@ namespace Lucene.Net.Index
                         Console.WriteLine("RIW: doRandomForceMerge(" + limit + ")");
                     }
                     IndexWriter.ForceMerge(limit);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, () => "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, () => "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
                 }
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
index 176882c..f872bc5 100644
--- a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
@@ -227,7 +227,7 @@ namespace Lucene.Net.Index
                                 if (toDeleteSubDocs.Count > 0 && Random.NextBoolean())
                                 {
                                     delSubDocs = toDeleteSubDocs[Random.Next(toDeleteSubDocs.Count)];
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !delSubDocs.Deleted);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(!delSubDocs.Deleted);
                                     toDeleteSubDocs.Remove(delSubDocs);
                                     // Update doc block, replacing prior packID
                                     packID = delSubDocs.PackID;
@@ -364,7 +364,7 @@ namespace Lucene.Net.Index
 
                             foreach (SubDocs subDocs in toDeleteSubDocs)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => !subDocs.Deleted);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(!subDocs.Deleted);
                                 delPackIDs.Add(subDocs.PackID);
                                 outerInstance.DeleteDocuments(new Term("packID", subDocs.PackID));
                                 subDocs.Deleted = true;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
index c3de506..4f7057c 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Search
                 try
                 {
                     bool remaining = @in.Score(collector, DocsEnum.NO_MORE_DOCS);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !remaining);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!remaining);
                 }
 #pragma warning disable 168
                 catch (NotSupportedException e)
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
index f183d86..c57819c 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
         {
             if (inOrder || !AcceptsDocsOutOfOrder)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc > lastCollected, () => "Out of order : " + lastCollected + " " + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(doc > lastCollected, () => "Out of order : " + lastCollected + " " + doc);
             }
             @in.Collect(doc);
             lastCollected = doc;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
index ed7ae45..3dc951a 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
@@ -105,10 +105,10 @@ namespace Lucene.Net.Search
 
         public override float GetScore()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(Iterating);
+            if (Debugging.AssertsEnabled) Debugging.Assert(Iterating());
             float score = @in.GetScore();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !float.IsNaN(score));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !float.IsNaN(score));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!float.IsNaN(score));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!float.IsNaN(score));
             return score;
         }
 
@@ -125,7 +125,7 @@ namespace Lucene.Net.Search
         {
             get
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(Iterating);
+                if (Debugging.AssertsEnabled) Debugging.Assert(Iterating());
                 return @in.Freq;
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
index 8f046f8..7331687 100644
--- a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
+++ b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search
 
         private static IndexReader MakeEmptyIndex(Random random, int numDocs)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(numDocs > 0);
             Directory d = new MockDirectoryWrapper(random, new RAMDirectory());
             IndexWriter w = new IndexWriter(d, new IndexWriterConfig(LuceneTestCase.TEST_VERSION_CURRENT, new MockAnalyzer(random)));
             for (int i = 0; i < numDocs; i++)
@@ -487,7 +487,7 @@ namespace Lucene.Net.Search
                     leafPtr++;
                 }
                 lastReader[0] = (AtomicReader)context.Reader;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => readerContextArray[leafPtr].Reader == context.Reader);
+                if (Debugging.AssertsEnabled) Debugging.Assert(readerContextArray[leafPtr].Reader == context.Reader);
                 this.scorer = null;
                 lastDoc[0] = -1;
             }
diff --git a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
index 811bcb7..e7f0b9e 100644
--- a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
+++ b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
@@ -71,7 +71,7 @@ namespace Lucene.Net.Search
         {
             lock (this)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
                 if (!previousMappings.TryGetValue(field, out Similarity sim) || sim == null)
                 {
                     sim = knownSims[Math.Max(0, Math.Abs(perFieldSeed ^ field.GetHashCode())) % knownSims.Count];
diff --git a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
index 78f47d9..67d887b 100644
--- a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
@@ -220,7 +220,7 @@ namespace Lucene.Net.Search
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => searchAfter == null); // not supported yet
+                    if (Debugging.AssertsEnabled) Debugging.Assert(searchAfter == null); // not supported yet
                     return s.LocalSearch(q, numHits, sort);
                 }
             }
@@ -306,7 +306,7 @@ namespace Lucene.Net.Search
                     this.outerInstance = nodeState;
                     this.nodeVersions = nodeVersions;
                     MyNodeID = nodeID;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => MyNodeID == nodeState.MyNodeID, () => "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(MyNodeID == nodeState.MyNodeID, () => "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
                 }
 
                 public override Query Rewrite(Query original)
@@ -348,7 +348,7 @@ namespace Lucene.Net.Search
 
                 public override TermStatistics TermStatistics(Term term, TermContext context)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => term != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(term != null);
                     long docFreq = 0;
                     long totalTermFreq = 0;
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
@@ -364,7 +364,7 @@ namespace Lucene.Net.Search
                             subStats = outerInstance.termStatsCache[key];
                             // We pre-cached during rewrite so all terms
                             // better be here...
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => subStats != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(subStats != null);
                         }
 
                         long nodeDocFreq = subStats.DocFreq;
@@ -419,7 +419,7 @@ namespace Lucene.Net.Search
                         }
                         // Collection stats are pre-shared on reopen, so,
                         // we better not have a cache miss:
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeStats != null, () => "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nodeStats != null, () => "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
 
                         long nodeDocCount = nodeStats.DocCount;
                         if (docCount >= 0 && nodeDocCount >= 0)
@@ -451,7 +451,7 @@ namespace Lucene.Net.Search
                             sumDocFreq = -1;
                         }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeStats.MaxDoc >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nodeStats.MaxDoc >= 0);
                         maxDoc += nodeStats.MaxDoc;
                     }
 
@@ -551,7 +551,7 @@ namespace Lucene.Net.Search
 
                 public override TopFieldDocs Search(Query query, int numHits, Sort sort)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => sort != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(sort != null);
                     TopDocs[] shardHits = new TopDocs[nodeVersions.Length];
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
                     {
@@ -604,7 +604,7 @@ namespace Lucene.Net.Search
 
             public void InitSearcher(long[] nodeVersions)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentShardSearcher == null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(currentShardSearcher == null);
                 Array.Copy(nodeVersions, 0, currentNodeVersions, 0, currentNodeVersions.Length);
                 currentShardSearcher = new ShardIndexSearcher(this, GetCurrentNodeVersions(), Mgr.Acquire().IndexReader, MyNodeID);
             }
@@ -781,8 +781,8 @@ namespace Lucene.Net.Search
             for (int nodeID = 0; nodeID < numNodes; nodeID++)
             {
                 IndexSearcher s = m_nodes[nodeID].Mgr.Acquire();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => s != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
+                if (Debugging.AssertsEnabled) Debugging.Assert(s != null);
                 try
                 {
                     BroadcastNodeReopen(nodeID, nodeVersions[nodeID], s);
diff --git a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
index 60aa77d..7428971 100644
--- a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
@@ -963,7 +963,7 @@ namespace Lucene.Net.Store
                                             {
                                                 if (endSet.Contains(s) && !startSet.Contains(s))
                                                 {
-                                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => pendingDeletions.Contains(s));
+                                                    if (Debugging.AssertsEnabled) Debugging.Assert(pendingDeletions.Contains(s));
                                                     if (LuceneTestCase.Verbose)
                                                     {
                                                         Console.WriteLine("MDW: Unreferenced check: Ignoring referenced file: " + s + " " + 
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Store
                                         extras += "\n\nThese files we had previously tried to delete, but couldn't: " + pendingDeletions;
                                     }
 
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
                                 }
 
                                 DirectoryReader ir1 = DirectoryReader.Open(this);
@@ -1034,7 +1034,7 @@ namespace Lucene.Net.Store
                                 DirectoryReader ir2 = DirectoryReader.Open(this);
                                 int numDocs2 = ir2.NumDocs;
                                 ir2.Dispose();
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => numDocs1 == numDocs2, () => "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(numDocs1 == numDocs2, () => "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
                             }
                         }
                     }
diff --git a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
index 3d9ea80..d2c7955 100644
--- a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
@@ -259,7 +259,7 @@ namespace Lucene.Net.Util
         [ExceptionToNetNumericConvention] // LUCENENET: This is for making test porting easier, keeping as-is
         internal int randomIntBetween(int min, int max)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => max >= min, () => "max must be >= min: " + min + ", " + max);
+            if (Debugging.AssertsEnabled) Debugging.Assert(max >= min, () => "max must be >= min: " + min + ", " + max);
             long range = (long)max - (long)min;
             if (range < int.MaxValue)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
index 52e6904..fa40f16 100644
--- a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
@@ -191,7 +191,7 @@ namespace Lucene.Net.Util.Automaton
                 }
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), () => "code=" + code + " min=" + t.Min + " max=" + t.Max);
+            if (Debugging.AssertsEnabled) Debugging.Assert(code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), () => "code=" + code + " min=" + t.Min + " max=" + t.Max);
             return code;
         }
 
@@ -399,7 +399,7 @@ namespace Lucene.Net.Util.Automaton
         {
             int numStates = a.GetNumberOfStates();
             a.ClearNumberedStates(); // force recomputation of cached numbered states
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numStates == a.GetNumberOfStates(), () => "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
+            if (Debugging.AssertsEnabled) Debugging.Assert(numStates == a.GetNumberOfStates(), () => "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
         }
     }
 
diff --git a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
index 1c74e96..430cce7 100644
--- a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
@@ -56,7 +56,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static BitSet RandomSet(int numBits, int numBitsSet)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numBitsSet <= numBits);
+            if (Debugging.AssertsEnabled) Debugging.Assert(numBitsSet <= numBits);
             BitSet set = new BitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
index e573e12..7fdfb90 100644
--- a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util
 
         public override void Message(string component, string message)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !message.Contains("non-bulk merges"));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!message.Contains("non-bulk merges"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
index 875dc69..94898c2 100644
--- a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
+++ b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
@@ -103,7 +103,7 @@ namespace Lucene.Net.Util.Fst
             for (int i = 0; i < ir.Length; i++)
             {
                 int x = ir.Int32s[ir.Offset + i];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => x >= 0 && x <= 255);
+                if (Debugging.AssertsEnabled) Debugging.Assert(x >= 0 && x <= 255);
                 br.Bytes[i] = (byte)x;
             }
             br.Length = ir.Length;
@@ -219,7 +219,7 @@ namespace Lucene.Net.Util.Fst
         // of the term prefix that matches
         private T Run(FST<T> fst, Int32sRef term, int[] prefixLength)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => prefixLength == null || prefixLength.Length == 1);
+            if (Debugging.AssertsEnabled) Debugging.Assert(prefixLength == null || prefixLength.Length == 1);
             FST.Arc<T> arc = fst.GetFirstArc(new FST.Arc<T>());
             T NO_OUTPUT = fst.Outputs.NoOutput;
             T output = NO_OUTPUT;
@@ -690,7 +690,7 @@ namespace Lucene.Net.Util.Fst
                             if (!termsMap.ContainsKey(term) && term.CompareTo(pairs[upto].Input) > 0)
                             {
                                 int pos = pairs.BinarySearch(new InputOutput<T>(term, default(T)));
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos < 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(pos < 0);
                                 upto = -(pos + 1);
 
                                 if (random.NextBoolean())
@@ -887,7 +887,7 @@ namespace Lucene.Net.Util.Fst
                     }
                     else
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => prune2 > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(prune2 > 0);
                         if (prune2 > 1 && cmo.Count >= prune2)
                         {
                             keep = true;
diff --git a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
index bf79a35..6460cbd 100644
--- a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
@@ -2678,7 +2678,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermsStatisticsEquals(string info, Terms leftTerms, Terms rightTerms)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount, info);
@@ -3053,7 +3053,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertStoredFieldsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Document leftDoc = leftReader.Document(i);
@@ -3100,7 +3100,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermVectorsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Fields leftFields = leftReader.GetTermVectors(i);
@@ -3270,7 +3270,7 @@ namespace Lucene.Net.Util
         // TODO: this is kinda stupid, we don't delete documents in the test.
         public virtual void AssertDeletedDocsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
             IBits leftBits = MultiFields.GetLiveDocs(leftReader);
             IBits rightBits = MultiFields.GetLiveDocs(rightReader);
 
@@ -3281,7 +3281,7 @@ namespace Lucene.Net.Util
                 return;
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
             Assert.AreEqual(leftBits.Length, rightBits.Length, info);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
@@ -3365,7 +3365,7 @@ namespace Lucene.Net.Util
         ////        if (TempDirBase == null)
         ////        {
         ////            DirectoryInfo directory = new DirectoryInfo(System.IO.Path.GetTempPath());
-        ////            //if (Debugging.AssertsEnabled) Debugging.Assert(() => directory.Exists && directory.Directory != null && directory.CanWrite());
+        ////            //if (Debugging.AssertsEnabled) Debugging.Assert(directory.Exists && directory.Directory != null && directory.CanWrite());
 
         ////            RandomizedContext ctx = RandomizedContext.Current;
         ////            Type clazz = ctx.GetTargetType;
@@ -3504,7 +3504,7 @@ namespace Lucene.Net.Util
         /// </summary>
         private static void RegisterToRemoveAfterSuite(FileSystemInfo f)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => f != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(f != null);
 
             if (LuceneTestCase.LeaveTemporary)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
index eafb5f2..315bfb4 100644
--- a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
@@ -29,13 +29,13 @@ namespace Lucene.Net.Util
     {
         public override void Message(string component, string message)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => component != null);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => message != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(component != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(message != null);
         }
 
         public override bool IsEnabled(string component)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => component != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(component != null);
             return true; // to actually enable logging, we just ignore on message()
         }
 
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
index f32b343..a0ca6d2 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
@@ -169,7 +169,7 @@ namespace Lucene.Net.Util
                                                                 !ShouldAvoidCodec("Lucene3x"))) // preflex-only setup
             {
                 codec = Codec.ForName("Lucene3x");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is PreFlexRWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((codec is PreFlexRWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
             }
             else if ("Lucene40".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
@@ -179,8 +179,8 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene40");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene40RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), () => "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((codec is Lucene40RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), () => "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene41".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -190,7 +190,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene41");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene41RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((codec is Lucene41RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene42".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -200,7 +200,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene42");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene42RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((codec is Lucene42RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene45".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -210,7 +210,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene45");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => (codec is Lucene45RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                if (Debugging.AssertsEnabled) Debugging.Assert((codec is Lucene45RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if (("random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) == false) 
                 || ("random".Equals(LuceneTestCase.TestDocValuesFormat, StringComparison.Ordinal) == false))
@@ -275,7 +275,7 @@ namespace Lucene.Net.Util
             }
             else
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                if (Debugging.AssertsEnabled) Debugging.Assert(false);
             }
             Codec.Default = codec;
 
diff --git a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
index 9730e3f..738c444 100644
--- a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
+++ b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Util
 
         public ThrottledIndexOutput(int bytesPerSecond, long flushDelayMillis, long closeDelayMillis, long seekDelayMillis, long minBytesWritten, IndexOutput @delegate)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => bytesPerSecond > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(bytesPerSecond > 0);
             this.@delegate = @delegate;
             this.bytesPerSecond = bytesPerSecond;
             this.flushDelayMillis = flushDelayMillis;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
index f0b5623..2daf82a 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
@@ -422,7 +422,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 // Same length: no change to offset
                             }
 
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => inputOffsets.Count == output.Length, () => "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(inputOffsets.Count == output.Length, () => "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
                         }
                         else
                         {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
index 6333c35..13b2cf3 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
@@ -211,7 +211,7 @@ namespace Lucene.Net.Analysis.Core
 
             internal FactoryAnalyzer(TokenizerFactory tokenizer, TokenFilterFactory tokenfilter, CharFilterFactory charFilter)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => tokenizer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(tokenizer != null);
                 this.tokenizer = tokenizer;
                 this.charFilter = charFilter;
                 this.tokenfilter = tokenfilter;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
index 20ea9ce..0dce8c7 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
@@ -172,7 +172,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => args.Length == 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
@@ -185,7 +185,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => args.Length == 3);
+                if (Debugging.AssertsEnabled) Debugging.Assert(args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
index 48f9ea8..c10147a 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
@@ -168,16 +168,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
+                if (Debugging.AssertsEnabled) Debugging.Assert(f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -208,16 +208,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
index cce39a6..a1ac6b5 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
@@ -184,16 +184,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
+                if (Debugging.AssertsEnabled) Debugging.Assert(f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -226,16 +226,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f.Exists);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => dicEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => affEntry != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
index 44f4ad2..ba8d1de 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
@@ -268,7 +268,7 @@ namespace Lucene.Net.Analysis.Synonym
 
         private string GetRandomString(char start, int alphabetSize, int length)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => alphabetSize <= 26);
+            if (Debugging.AssertsEnabled) Debugging.Assert(alphabetSize <= 26);
             char[] s = new char[2 * length];
             for (int charIDX = 0; charIDX < length; charIDX++)
             {
diff --git a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
index 5c1afbf..b0d4a31 100644
--- a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
+++ b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
@@ -154,7 +154,7 @@ namespace Lucene.Net.Facet
                     if (numInRow > 1)
                     {
                         Array.Sort(labelValues, i - numInRow, i - (i - numInRow), Comparer<LabelAndValue>.Create((a,b)=> {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => (double)a.Value == (double)b.Value);
+                            if (Debugging.AssertsEnabled) Debugging.Assert((double)a.Value == (double)b.Value);
                             return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label));
                         }));
                     }
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index a9d27ab..537dada 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -1197,7 +1197,7 @@ namespace Lucene.Net.Facet.Range
 
             protected override Facets BuildFacetsResult(FacetsCollector drillDowns, FacetsCollector[] drillSideways, string[] drillSidewaysDims)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => drillSideways.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(drillSideways.Length == 1);
                 return new DoubleRangeFacetCounts("field", vs, drillSideways[0], fastMatchFilter, ranges);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
index 09c2ed7..2e95b28 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
@@ -385,7 +385,7 @@ namespace Lucene.Net.Facet.Taxonomy
             public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
             {
                 Scorer scorer = (Scorer)context["scorer"];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => scorer != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(scorer != null);
                 return new DoubleDocValuesAnonymousInnerClassHelper(this, scorer);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
index d89256a..97be3a1 100644
--- a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
+++ b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
@@ -866,7 +866,7 @@ namespace Lucene.Net.Facet
 
             public virtual void Collect(int doc)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc > lastDocID);
+                if (Debugging.AssertsEnabled) Debugging.Assert(doc > lastDocID);
                 lastDocID = doc;
             }
 
@@ -948,8 +948,8 @@ namespace Lucene.Net.Facet
 
             public virtual void Inc(int[] dims, int[] dims2, int onlyDim)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => dims.Length == counts.Length);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => dims2.Length == counts.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(dims.Length == counts.Length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(dims2.Length == counts.Length);
                 for (int dim = 0; dim < dims.Length; dim++)
                 {
                     if (onlyDim == -1 || dim == onlyDim)
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index 3329b69..07d085c 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -559,7 +559,7 @@ namespace Lucene.Net.Search.Grouping
             Field[] facetFields;
             if (useDv)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !multipleFacetValuesPerDocument);
+                if (Debugging.AssertsEnabled) Debugging.Assert(!multipleFacetValuesPerDocument);
                 facetFields = new Field[2];
                 facetFields[0] = NewStringField("facet", "", Field.Store.NO);
                 doc.Add(facetFields[0]);
@@ -816,7 +816,7 @@ namespace Lucene.Net.Search.Grouping
         {
             BytesRef facetPrefixBR = facetPrefix == null ? null : new BytesRef(facetPrefix);
             // DocValues cannot be multi-valued:
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => !multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
+            if (Debugging.AssertsEnabled) Debugging.Assert(!multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
             return TermGroupFacetCollector.CreateTermGroupFacetCollector(groupField, facetField, multipleFacetsPerDocument, facetPrefixBR, Random.nextInt(1024));
         }
 
diff --git a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
index 99189a1..8228ecc 100644
--- a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
+++ b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
@@ -775,8 +775,8 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             protected override IList<string[]> LoadFieldValues(IndexSearcher searcher, string[] fields, int[] docids, int maxLength)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fields.Length == 1);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docids.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fields.Length == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docids.Length == 1);
                 String[][] contents = RectangularArrays.ReturnRectangularArray<string>(1, 1); //= new String[1][1];
                 contents[0][0] = text;
                 return contents;
@@ -1179,7 +1179,7 @@ namespace Lucene.Net.Search.PostingsHighlight
         {
             protected override char GetMultiValuedSeparator(string field)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => field.Equals("body", StringComparison.Ordinal));
+                if (Debugging.AssertsEnabled) Debugging.Assert(field.Equals("body", StringComparison.Ordinal));
                 return '\u2029';
             }
         }
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index 09ea77f..59de865 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -1030,7 +1030,7 @@ namespace Lucene.Net.Tests.Join
                     {
                         DocsEnum docsEnum = MultiFields.GetTermDocsEnum(topLevelReader,
                             MultiFields.GetLiveDocs(topLevelReader), "id", new BytesRef(otherSideDoc.id), 0);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => docsEnum != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(docsEnum != null);
                         int doc = docsEnum.NextDoc();
                         expectedResult.Set(doc);
                     }
diff --git a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
index 32a1bce..f8417b7 100644
--- a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
@@ -65,8 +65,8 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override Query GetQuery(string query, ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser, () => "Parameter must be instance of QueryParser");
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC != null, () => "Parameter must not be null");
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser, () => "Parameter must be instance of QueryParser");
             QueryParser qp = (QueryParser)cqpC;
             return qp.Parse(query);
         }
@@ -83,35 +83,35 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.OR;
         }
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.AND;
         }
 
         public override void SetAnalyzeRangeTerms(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AnalyzeRangeTerms = (value);
         }
 
         public override void SetAutoGeneratePhraseQueries(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AutoGeneratePhraseQueries = value;
         }
 
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC, string field, DateTools.Resolution value)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is QueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.SetDateResolution(field, value);
         }
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
index f9d2855..5cdeb98 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
@@ -59,8 +59,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override Query GetQuery(String query, ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => (cqpC is StandardQueryParser), () => "Parameter must be instance of StandardQueryParser");
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC != null, () => "Parameter must not be null");
+            if (Debugging.AssertsEnabled) Debugging.Assert((cqpC is StandardQueryParser), () => "Parameter must be instance of StandardQueryParser");
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             return Parse(query, qp);
         }
@@ -80,7 +80,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.OR);
         }
@@ -88,7 +88,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.AND);
         }
@@ -111,7 +111,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC,
             string field, DateTools.Resolution value)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => cqpC is StandardQueryParser);
+            if (Debugging.AssertsEnabled) Debugging.Assert(cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DateResolutionMap.Put(field, value);
         }
diff --git a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
index a6fe124..38f8c2f 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
@@ -461,7 +461,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
index ee05bc1..f4dfbb1 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
@@ -367,7 +367,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
index 6f54dd4..eb64791 100644
--- a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
+++ b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
@@ -152,7 +152,7 @@ namespace Lucene.Net.Spatial
 
         private double randomGaussianMinMeanMax(double min, double mean, double max)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => mean > min);
+            if (Debugging.AssertsEnabled) Debugging.Assert(mean > min);
             return randomGaussianMeanMax(mean - min, max - min) + min;
         }
 
@@ -166,7 +166,7 @@ namespace Lucene.Net.Spatial
         private double randomGaussianMeanMax(double mean, double max)
         {
             // DWS: I verified the results empirically
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => mean <= max && mean >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(mean <= max && mean >= 0);
             double g = randomGaussian();
             double mean2 = mean;
             double flip = 1;
@@ -180,7 +180,7 @@ namespace Lucene.Net.Spatial
             // 1 standard deviation alters the calculation
             double pivotMax = max - mean2;
             double pivot = Math.Min(mean2, pivotMax / 2);//from 0 to max-mean2
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => pivot >= 0 && pivotMax >= pivot && g >= 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(pivot >= 0 && pivotMax >= pivot && g >= 0);
             double pivotResult;
             if (g <= 1)
                 pivotResult = pivot * g;
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
index 4b7301d..bc2ad0f 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
@@ -651,7 +651,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(false);
                     return 0;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
index 4857d73..d88b6f7 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
@@ -603,7 +603,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(false);
                     return 0;
                 }
             }
@@ -1313,7 +1313,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 else
                 {
                     int c = CHARSEQUENCE_COMPARER.Compare(a.Key, b.Key);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => c != 0, () => "term=" + a.Key);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(c != 0, () => "term=" + a.Key);
                     return c;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
index 0780c82..e0778ea 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
@@ -680,7 +680,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     return tokens[k];
                 }
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+            if (Debugging.AssertsEnabled) Debugging.Assert(false);
             return null;
         }
 
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
index 14251e7..883a110 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
@@ -75,7 +75,7 @@ namespace Lucene.Net.Search.Suggest
 
         public override void SetUp()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "disable assertions before running benchmarks!");
+            if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "disable assertions before running benchmarks!");
             IList<Input> input = ReadTop50KWiki();
             input.Shuffle(Random);
             dictionaryInput = input.ToArray();
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Suggest
             List<Input> input = new List<Input>();
 
             var resource = typeof(LookupBenchmarkTest).FindAndGetManifestResourceStream("Top50KWiki.utf8");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => resource != null, () => "Resource missing: Top50KWiki.utf8");
+            if (Debugging.AssertsEnabled) Debugging.Assert(resource != null, () => "Resource missing: Top50KWiki.utf8");
 
             string line = null;
             using (TextReader br = new StreamReader(resource, UTF_8))
diff --git a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
index 1322b74..f351acb 100644
--- a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis
                     pos += minPosLength;
                     offset = 2 * pos;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => maxPos <= pos, () => "input string mal-formed: posLength>1 tokens hang over the end");
+                if (Debugging.AssertsEnabled) Debugging.Assert(maxPos <= pos, () => "input string mal-formed: posLength>1 tokens hang over the end");
             }
         }
 
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
index 40b002f..d56e040 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
@@ -296,7 +296,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// </summary>
         public virtual void AssertTermsStatistics(Terms leftTerms, Terms rightTerms)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
+            if (Debugging.AssertsEnabled) Debugging.Assert(leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount);
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
index 0a2e89e..3379c03 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
@@ -113,7 +113,7 @@ namespace Lucene.Net.Codecs.PerField
             {
                 Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                 Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => ireader.Leaves.Count == 1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(ireader.Leaves.Count == 1);
                 NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv1");
                 Assert.AreEqual(5, dv.Get(hits.ScoreDocs[i].Doc));
                 BinaryDocValues dv2 = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv2");
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
index 2ed15aa..ba498e7 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
@@ -434,7 +434,7 @@ namespace Lucene.Net.Index
             // true if this is a 4.2+ index
             bool is42Index = MultiFields.GetMergedFieldInfos(reader).FieldInfo("dvSortedSet") != null;
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => is40Index); // NOTE: currently we can only do this on trunk!
+            if (Debugging.AssertsEnabled) Debugging.Assert(is40Index); // NOTE: currently we can only do this on trunk!
 
             IBits liveDocs = MultiFields.GetLiveDocs(reader);
 
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
index 417df93..1a1fea9 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
@@ -1039,7 +1039,7 @@ namespace Lucene.Net.Index
             Assert.AreEqual(1, td.TotalHits);
             AtomicReader wrapper = SlowCompositeReaderWrapper.Wrap(ir);
             DocsAndPositionsEnum de = wrapper.GetTermPositionsEnum(new Term("field3", "broken"));
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => de != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(de != null);
             Assert.AreEqual(0, de.NextDoc());
             Assert.AreEqual(0, de.NextPosition());
             ir.Dispose();
diff --git a/src/Lucene.Net.Tests/Index/TestCodecs.cs b/src/Lucene.Net.Tests/Index/TestCodecs.cs
index 2888663..a9c8d89 100644
--- a/src/Lucene.Net.Tests/Index/TestCodecs.cs
+++ b/src/Lucene.Net.Tests/Index/TestCodecs.cs
@@ -446,7 +446,7 @@ namespace Lucene.Net.Index
                     for (int i = 0; i < NUM_TEST_THREADS - 1; i++)
                     {
                         threads[i].Join();
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !threads[i].failed);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!threads[i].failed);
                     }
 
                 }
@@ -759,14 +759,14 @@ namespace Lucene.Net.Index
                                         if (doc == DocIdSetIterator.NO_MORE_DOCS)
                                         {
                                             // skipped past last doc
-                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto2 == term2.docs.Length - 1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(upto2 == term2.docs.Length - 1);
                                             ended = true;
                                             break;
                                         }
                                         else
                                         {
                                             // skipped to next doc
-                                            if (Debugging.AssertsEnabled) Debugging.Assert(() => upto2 < term2.docs.Length - 1);
+                                            if (Debugging.AssertsEnabled) Debugging.Assert(upto2 < term2.docs.Length - 1);
                                             if (doc >= term2.docs[1 + upto2])
                                             {
                                                 upto2++;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
index a2517f5..2a80fdf 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
@@ -2140,14 +2140,14 @@ namespace Lucene.Net.Index
             r = w.GetReader();
             long version2 = r.Version;
             r.Dispose();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => version2 > version);
+            if (Debugging.AssertsEnabled) Debugging.Assert(version2 > version);
 
             w.DeleteDocuments(new Term("id", "0"));
             r = w.GetReader();
             w.Dispose();
             long version3 = r.Version;
             r.Dispose();
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => version3 > version2);
+            if (Debugging.AssertsEnabled) Debugging.Assert(version3 > version2);
             d.Dispose();
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
index ffdcfdd..eee2d87 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
@@ -315,7 +315,7 @@ namespace Lucene.Net.Index
                         }
                         for (int i = 0; i < merge.Segments.Count; i++)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => merge.Segments[i].Info.DocCount < 20);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(merge.Segments[i].Info.DocCount < 20);
                         }
                         writer.Merge(merge);
                     }
diff --git a/src/Lucene.Net.Tests/Index/TestIndexableField.cs b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
index 4308d1a..f171897 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexableField.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
@@ -317,7 +317,7 @@ namespace Lucene.Net.Index
                         }
                         else
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => stringValue != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(stringValue != null);
                             Assert.AreEqual(stringValue, f.GetStringValue());
                         }
                     }
@@ -424,7 +424,7 @@ namespace Lucene.Net.Index
                         return false;
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldUpto < outerInstance.fieldCount);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(fieldUpto < outerInstance.fieldCount);
                     if (fieldUpto == 0)
                     {
                         fieldUpto = 1;
diff --git a/src/Lucene.Net.Tests/Index/TestLongPostings.cs b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
index c9859d7..4ffecfa 100644
--- a/src/Lucene.Net.Tests/Index/TestLongPostings.cs
+++ b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
@@ -462,9 +462,9 @@ namespace Lucene.Net.Index
                 else
                 {
                     docs = postings = TestUtil.Docs(Random, r, "field", new BytesRef(term), null, null, DocsFlags.FREQS);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => postings != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(postings != null);
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docs != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docs != null);
 
                 int docID = -1;
                 while (docID < DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
index 5dfadbf..9a7916d 100644
--- a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
 
         protected override Directory GetDirectory(Directory @in)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in is MockDirectoryWrapper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(@in is MockDirectoryWrapper);
             if (!useNonNrtReaders)
             {
                 ((MockDirectoryWrapper)@in).AssertNoDeleteOpenFile = true;
diff --git a/src/Lucene.Net.Tests/Index/TestPayloads.cs b/src/Lucene.Net.Tests/Index/TestPayloads.cs
index 2129822..d536b10 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloads.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloads.cs
@@ -310,7 +310,7 @@ namespace Lucene.Net.Index
             // this test needs the random data to be valid unicode
             string s = TestUtil.RandomFixedByteLengthUnicodeString(Random, data.Length);
             var b = s.GetBytes(utf8);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => b.Length == data.Length);
+            if (Debugging.AssertsEnabled) Debugging.Assert(b.Length == data.Length);
             System.Buffer.BlockCopy(b, 0, data, 0, b.Length);
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
index f38c941..d251def 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
@@ -79,7 +79,7 @@ namespace Lucene.Net.Index
 
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(1, "field");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
@@ -128,7 +128,7 @@ namespace Lucene.Net.Index
             writer.AddDocument(doc);
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(0, "field");
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
diff --git a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
index 6e96835..0f3ac91 100644
--- a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
@@ -177,9 +177,9 @@ namespace Lucene.Net.Index
                     {
                         dp.NextPosition();
                         int start = dp.StartOffset;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(start >= 0);
                         int end = dp.EndOffset;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= 0 && end >= start);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(end >= 0 && end >= start);
                         // check that the offsets correspond to the term in the src text
                         Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals(term, StringComparison.Ordinal));
                         if (withPayloads)
@@ -208,9 +208,9 @@ namespace Lucene.Net.Index
                     string storedNumbers = reader.Document(doc).Get("numbers");
                     dp.NextPosition();
                     int start = dp.StartOffset;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(start >= 0);
                     int end = dp.EndOffset;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => end >= 0 && end >= start);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(end >= 0 && end >= start);
                     // check that the offsets correspond to the term in the src text
                     Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals("hundred", StringComparison.Ordinal));
                     if (withPayloads)
diff --git a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
index b7d7a3c..3209749 100644
--- a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
@@ -347,7 +347,7 @@ namespace Lucene.Net.Index
             }
             if (r1.NumDocs != r2.NumDocs)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => false, () => "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
+                if (Debugging.AssertsEnabled) Debugging.Assert(false, () => "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
             }
             bool hasDeletes = !(r1.MaxDoc == r2.MaxDoc && r1.NumDocs == r1.MaxDoc);
 
@@ -682,7 +682,7 @@ namespace Lucene.Net.Index
                 IIndexableField f2 = ff2[i];
                 if (f1.GetBinaryValue() != null)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => f2.GetBinaryValue() != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(f2.GetBinaryValue() != null);
                 }
                 else
                 {
diff --git a/src/Lucene.Net.Tests/Index/TestStressNRT.cs b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
index 3154b56..b552cdb 100644
--- a/src/Lucene.Net.Tests/Index/TestStressNRT.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
@@ -263,8 +263,8 @@ namespace Lucene.Net.Index
                                 {
                                     // install the new reader if it's newest (and check the current version since another reader may have already been installed)
                                     //System.out.println(Thread.currentThread().getName() + ": newVersion=" + newReader.getVersion());
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => newReader.RefCount > 0);
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.reader.RefCount > 0);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(newReader.RefCount > 0);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.reader.RefCount > 0);
                                     if (newReader.Version > outerInstance.reader.Version)
                                     {
                                         if (Verbose)
diff --git a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
index d8dada1..5ac0bf5 100644
--- a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
@@ -829,7 +829,7 @@ namespace Lucene.Net.Index
                     }
                     else
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => loc >= -validTerms.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(loc >= -validTerms.Length);
                         Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, result);
                     }
                 }
diff --git a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
index bd1216b..d738765 100644
--- a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
+++ b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search.Spans
             }
 
             int subIndex = ReaderUtil.SubIndex(target, leaves);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => subIndex >= leafOrd);
+            if (Debugging.AssertsEnabled) Debugging.Assert(subIndex >= leafOrd);
             if (subIndex != leafOrd)
             {
                 AtomicReaderContext ctx = leaves[subIndex];
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
index b870992..a257e2b 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
@@ -119,7 +119,7 @@ namespace Lucene.Net.Search
 
             public override bool Score(ICollector c, int maxDoc)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc == -1);
+                if (Debugging.AssertsEnabled) Debugging.Assert(doc == -1);
                 doc = 3000;
                 FakeScorer fs = new FakeScorer();
                 fs.doc = doc;
diff --git a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
index 8a244a0..80747c3 100644
--- a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
@@ -234,7 +234,7 @@ namespace Lucene.Net.Search
 
             Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random, new TermQuery(new Term("field", "a"))));
             IndexSearcher s = NewSearcher(r);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => s is AssertingIndexSearcher);
+            if (Debugging.AssertsEnabled) Debugging.Assert(s is AssertingIndexSearcher);
             // this used to fail
             s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
 
diff --git a/src/Lucene.Net.Tests/Search/TestFieldCache.cs b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
index 7295a56..4c93135 100644
--- a/src/Lucene.Net.Tests/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
@@ -372,7 +372,7 @@ namespace Lucene.Net.Search
                         break;
                     }
                     long ord = termOrds.NextOrd();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ord != SortedSetDocValues.NO_MORE_ORDS);
                     BytesRef scratch = new BytesRef();
                     termOrds.LookupOrd(ord, scratch);
                     Assert.AreEqual(v, scratch);
diff --git a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
index de9b7be..bdecf25 100644
--- a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
+++ b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
@@ -365,14 +365,14 @@ namespace Lucene.Net.Search
                 this.sims = new SimScorer[(int)dv.ValueCount];
                 foreach (BooleanClause clause in bq.GetClauses())
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !clause.IsProhibited);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !clause.IsRequired);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!clause.IsProhibited);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!clause.IsRequired);
                     Term term = ((TermQuery)clause.Query).Term;
                     long ord = dv.LookupTerm(term.Bytes);
                     if (ord >= 0)
                     {
                         bool success = ords.Add(ord);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => success); // no dups
+                        if (Debugging.AssertsEnabled) Debugging.Assert(success); // no dups
                         TermContext context = TermContext.Build(reader.Context, term);
                         SimWeight w = weight.Similarity.ComputeWeight(1f, searcher.CollectionStatistics("field"), searcher.TermStatistics(term, context));
                         var dummy = w.GetValueForNormalization(); // ignored
@@ -384,7 +384,7 @@ namespace Lucene.Net.Search
 
             public override float GetScore()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => score != 0, currentMatched.ToString);
+                if (Debugging.AssertsEnabled) Debugging.Assert(score != 0, currentMatched.ToString);
                 return (float)score * ((BooleanWeight)m_weight).Coord(currentMatched, ((BooleanWeight)m_weight).MaxCoord);
             }
 
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
 
             public override int NextDoc()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentDoc != NO_MORE_DOCS);
+                if (Debugging.AssertsEnabled) Debugging.Assert(currentDoc != NO_MORE_DOCS);
                 for (currentDoc = currentDoc + 1; currentDoc < maxDoc; currentDoc++)
                 {
                     currentMatched = 0;
diff --git a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
index d1e61d8..03e4f65 100644
--- a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
+++ b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
@@ -223,7 +223,7 @@ namespace Lucene.Net.Search
             foreach (string field in vectors)
             {
                 Terms terms = vectors.GetTerms(field);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => terms != null);
+                if (Debugging.AssertsEnabled) Debugging.Assert(terms != null);
                 VerifyVector(terms.GetIterator(null), num);
             }
         }
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
index 050e28c..82e70ea 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
@@ -474,13 +474,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             int lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2 * lower;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
index 4262d3c..db8377f 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
@@ -501,13 +501,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             long lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2L * lower;
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => lower < upper);
+            if (Debugging.AssertsEnabled) Debugging.Assert(lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
index 8118ca6..8162e52 100644
--- a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
+++ b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
@@ -418,7 +418,7 @@ namespace Lucene.Net.Search
 //#endif
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => docId >= 0, () => " base=" + docBase + " doc=" + doc);
+                if (Debugging.AssertsEnabled) Debugging.Assert(docId >= 0, () => " base=" + docBase + " doc=" + doc);
                 bits.Set(docId);
                 lastDocCollected = docId;
             }
diff --git a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
index 5addb89..8f72234 100644
--- a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
+++ b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
@@ -76,7 +76,7 @@ namespace Lucene.Net.Util.Automaton
                 nonSurrogateCount = endCode - startCode + 1 - (UnicodeUtil.UNI_SUR_LOW_END - UnicodeUtil.UNI_SUR_HIGH_START + 1);
             }
 
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => nonSurrogateCount > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(nonSurrogateCount > 0);
 
             for (int iter = 0; iter < iters; iter++)
             {
@@ -95,8 +95,8 @@ namespace Lucene.Net.Util.Automaton
                     }
                 }
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => code >= startCode && code <= endCode, () => "code=" + code + " start=" + startCode + " end=" + endCode);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => !IsSurrogate(code));
+                if (Debugging.AssertsEnabled) Debugging.Assert(code >= startCode && code <= endCode, () => "code=" + code + " start=" + startCode + " end=" + endCode);
+                if (Debugging.AssertsEnabled) Debugging.Assert(!IsSurrogate(code));
 
                 Assert.IsTrue(Matches(a, code), "DFA for range " + startCode + "-" + endCode + " failed to match code=" + code);
             }
diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
index b262eda..0720328 100644
--- a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
+++ b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
@@ -571,7 +571,7 @@ namespace Lucene.Net.Util.Fst
                     long tMid = Environment.TickCount;
                     Console.WriteLine(((tMid - tStart) / 1000.0) + " sec to add all terms");
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => builder.TermCount == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(builder.TermCount == ord);
                     FST<T> fst = builder.Finish();
                     long tEnd = Environment.TickCount;
                     Console.WriteLine(((tEnd - tMid) / 1000.0) + " sec to finish/pack");
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
index 007eee8..5d3d040 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
@@ -52,7 +52,7 @@ namespace Lucene.Net.Util.Packed
                 {
                     doc = NO_MORE_DOCS;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => doc < numBits);
+                if (Debugging.AssertsEnabled) Debugging.Assert(doc < numBits);
                 return doc;
             }
 
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
index 9111a35..ee29105 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeAdvanceToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test advancing to multiples of m
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(m > 0);
             long previousValue = -1L;
             long index = 0;
             long mm = m;
@@ -120,7 +120,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeBackToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test backing to multiples of m
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => m > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(m > 0);
             efd.ToAfterSequence();
             int index = values.Length - 1;
             if (index < 0)
@@ -135,7 +135,7 @@ namespace Lucene.Net.Util.Packed
             while (index >= 0)
             {
                 expValue = values[index];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => mm < previousValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(mm < previousValue);
                 if (expValue <= mm)
                 {
                     long backValue_ = efd.BackToValue(mm);
diff --git a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
index 8fad1f7..9c044cc 100644
--- a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
+++ b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Util
                 r2.NextBytes(bytes);
                 dataOutput.WriteBytes(bytes, bytes.Length);
                 long fp = dataOutput.GetFilePointer();
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => fp == lastFP + numBytes);
+                if (Debugging.AssertsEnabled) Debugging.Assert(fp == lastFP + numBytes);
                 lastFP = fp;
                 netBytes += numBytes;
             }
diff --git a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
index 3c272c7..a71ef90 100644
--- a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static OpenBitSet RandomOpenSet(int numBits, int numBitsSet)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => numBitsSet <= numBits);
+            if (Debugging.AssertsEnabled) Debugging.Assert(numBitsSet <= numBits);
             OpenBitSet set = new OpenBitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/Lucene.Net/Analysis/NumericTokenStream.cs b/src/Lucene.Net/Analysis/NumericTokenStream.cs
index ace2805..67a3671 100644
--- a/src/Lucene.Net/Analysis/NumericTokenStream.cs
+++ b/src/Lucene.Net/Analysis/NumericTokenStream.cs
@@ -178,7 +178,7 @@ namespace Lucene.Net.Analysis
 
             public void FillBytesRef()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => ValueSize == 64 || ValueSize == 32);
+                if (Debugging.AssertsEnabled) Debugging.Assert(ValueSize == 64 || ValueSize == 32);
                 if (ValueSize == 64)
                 {
                     NumericUtils.Int64ToPrefixCoded(_value, Shift, _bytes);
diff --git a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
index c70f8fe..c015135 100644
--- a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
+++ b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
@@ -155,7 +155,7 @@ namespace Lucene.Net.Analysis
                 {
                     posInc = 1;
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => pos > -1 || posInc > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(pos > -1 || posInc > 0);
 
                 if (posInc > 0)
                 {
@@ -163,7 +163,7 @@ namespace Lucene.Net.Analysis
                     pos += posInc;
 
                     posData = positions.Get(pos);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => posData.leaving == null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(posData.leaving == null);
 
                     if (posData.arriving == null)
                     {
diff --git a/src/Lucene.Net/Analysis/Tokenizer.cs b/src/Lucene.Net/Analysis/Tokenizer.cs
index 36acdea..249b60f 100644
--- a/src/Lucene.Net/Analysis/Tokenizer.cs
+++ b/src/Lucene.Net/Analysis/Tokenizer.cs
@@ -115,7 +115,7 @@ namespace Lucene.Net.Analysis
                 throw new InvalidOperationException("TokenStream contract violation: Close() call missing");
             }
             this.inputPending = input;
-            if (Debugging.AssertsEnabled) Debugging.Assert(SetReaderTestPoint);
+            if (Debugging.AssertsEnabled) Debugging.Assert(SetReaderTestPoint());
         }
 
         public override void Reset()
diff --git a/src/Lucene.Net/Codecs/BlockTermState.cs b/src/Lucene.Net/Codecs/BlockTermState.cs
index 13a8bd7..3768b6b 100644
--- a/src/Lucene.Net/Codecs/BlockTermState.cs
+++ b/src/Lucene.Net/Codecs/BlockTermState.cs
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs
 
         public override void CopyFrom(TermState other)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => other is BlockTermState, () => "can not copy from " + other.GetType().Name);
+            if (Debugging.AssertsEnabled) Debugging.Assert(other is BlockTermState, () => "can not copy from " + other.GetType().Name);
             BlockTermState other2 = (BlockTermState)other;
             base.CopyFrom(other);
             DocFreq = other2.DocFreq;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
index a3f1591..5d1b55b 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
@@ -167,13 +167,13 @@ namespace Lucene.Net.Codecs
                 {
                     int field = @in.ReadVInt32();
                     long numTerms = @in.ReadVInt64();
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms >= 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(numTerms >= 0);
                     int numBytes = @in.ReadVInt32();
                     BytesRef rootCode = new BytesRef(new byte[numBytes]);
                     @in.ReadBytes(rootCode.Bytes, 0, numBytes);
                     rootCode.Length = numBytes;
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => fieldInfo != null, () => "field=" + field);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(fieldInfo != null, () => "field=" + field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : @in.ReadVInt64();
                     long sumDocFreq = @in.ReadVInt64();
                     int docCount = @in.ReadVInt32();
@@ -291,7 +291,7 @@ namespace Lucene.Net.Codecs
 
         public override Terms GetTerms(string field)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => field != null);
+            if (Debugging.AssertsEnabled) Debugging.Assert(field != null);
             FieldReader ret;
             fields.TryGetValue(field, out ret);
             return ret;
@@ -478,7 +478,7 @@ namespace Lucene.Net.Codecs
                 }
                 endBlockCount++;
                 long otherBytes = frame.fpEnd - frame.fp - frame.suffixesReader.Length - frame.statsReader.Length;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => otherBytes > 0, () => "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
+                if (Debugging.AssertsEnabled) Debugging.Assert(otherBytes > 0, () => "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
                 TotalBlockOtherBytes += otherBytes;
             }
 
@@ -491,9 +491,9 @@ namespace Lucene.Net.Codecs
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => startBlockCount == endBlockCount, () => "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
-                    Debugging.Assert(() => TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, () => "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
-                    Debugging.Assert(() => TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, () => "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
+                    Debugging.Assert(startBlockCount == endBlockCount, () => "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
+                    Debugging.Assert(TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, () => "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
+                    Debugging.Assert(TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, () => "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
                 }
             }
 
@@ -532,7 +532,7 @@ namespace Lucene.Net.Codecs
                             @out.AppendLine("      " + prefix.ToString().PadLeft(2, ' ') + ": " + blockCount);
                         }
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => TotalBlockCount == total);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(TotalBlockCount == total);
                 }
                 return @out.ToString();
             }
@@ -563,7 +563,7 @@ namespace Lucene.Net.Codecs
             internal FieldReader(BlockTreeTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, BytesRef rootCode, long sumTotalTermFreq, long sumDocFreq, int docCount, long indexStartFP, int longsSize, IndexInput indexIn)
             {
                 this.outerInstance = outerInstance;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numTerms > 0);
                 this.fieldInfo = fieldInfo;
                 //DEBUG = BlockTreeTermsReader.DEBUG && fieldInfo.name.Equals("id", StringComparison.Ordinal);
                 this.numTerms = numTerms;
@@ -763,7 +763,7 @@ namespace Lucene.Net.Codecs
 
                     internal void LoadNextFloorBlock()
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => numFollowFloorBlocks > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(numFollowFloorBlocks > 0);
                         //if (DEBUG) System.out.println("    loadNextFoorBlock trans=" + transitions[transitionIndex]);
 
                         do
@@ -848,7 +848,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code_ = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code_ >> 1);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => entCount > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(entCount > 0);
                         isLastInFloor = (code_ & 1) != 0;
 
                         // term suffixes:
@@ -909,7 +909,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -920,7 +920,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -947,7 +947,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => limit > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Codecs
 
                     FST.Arc<BytesRef> arc = outerInstance.index.GetFirstArc(arcs[0]);
                     // Empty string prefix must have an output in the index!
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
 
                     // Special pushFrame since it's the first one:
                     Frame f = stack[0];
@@ -1036,7 +1036,7 @@ namespace Lucene.Net.Codecs
                     f.Load(outerInstance.rootCode);
 
                     // for assert:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => SetSavedStartTerm(startTerm));
+                    if (Debugging.AssertsEnabled) Debugging.Assert(SetSavedStartTerm(startTerm));
 
                     currentFrame = f;
                     if (startTerm != null)
@@ -1070,7 +1070,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stack[ord].ord == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1104,7 +1104,7 @@ namespace Lucene.Net.Codecs
                     // possible:
                     FST.Arc<BytesRef> arc = currentFrame.arc;
                     int idx = currentFrame.prefix;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.suffix > 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentFrame.suffix > 0);
                     BytesRef output = currentFrame.outputPrefix;
                     while (idx < f.prefix)
                     {
@@ -1113,14 +1113,14 @@ namespace Lucene.Net.Codecs
                         // case by using current arc as starting point,
                         // passed to findTargetArc
                         arc = outerInstance.index.FindTargetArc(target, arc, GetArc(1 + idx), fstReader);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc != null);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc != null);
                         output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
                         idx++;
                     }
 
                     f.arc = arc;
                     f.outputPrefix = output;
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                     f.Load(outerInstance.outerInstance.fstOutputs.Add(output, arc.NextFinalOutput));
                     return f;
                 }
@@ -1171,7 +1171,7 @@ namespace Lucene.Net.Codecs
                     for (int idx = 0; idx < currentFrame.suffix; idx++)
                     {
                         state = runAutomaton.Step(state, currentFrame.suffixBytes[currentFrame.startBytePos + idx] & 0xff);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => state != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(state != -1);
                     }
                     return state;
                 }
@@ -1183,13 +1183,13 @@ namespace Lucene.Net.Codecs
                 private void SeekToStartTerm(BytesRef target)
                 {
                     //if (DEBUG) System.out.println("seek to startTerm=" + target.utf8ToString());
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.ord == 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(currentFrame.ord == 0);
                     if (term.Length < target.Length)
                     {
                         term.Bytes = ArrayUtil.Grow(term.Bytes, target.Length);
                     }
                     FST.Arc<BytesRef> arc = arcs[0];
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == currentFrame.arc);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(arc == currentFrame.arc);
 
                     for (int idx = 0; idx <= target.Length; idx++)
                     {
@@ -1267,7 +1267,7 @@ namespace Lucene.Net.Codecs
                         }
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => false);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(false);
                 }
 
                 public override BytesRef Next()
@@ -1297,7 +1297,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.lastSubFP == lastFP);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(currentFrame.lastSubFP == lastFP);
                                 //if (DEBUG) System.out.println("\n  frame ord=" + currentFrame.ord + " prefix=" + brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" : currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" + currentFrame.outputPrefix);
                             }
                         }
@@ -1351,7 +1351,7 @@ namespace Lucene.Net.Codecs
                             byte[] commonSuffixBytes = compiledAutomaton.CommonSuffixRef.Bytes;
 
                             int lenInPrefix = compiledAutomaton.CommonSuffixRef.Length - currentFrame.suffix;
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(compiledAutomaton.CommonSuffixRef.Offset == 0);
                             int suffixBytesPos;
                             int commonSuffixBytesPos = 0;
 
@@ -1362,7 +1362,7 @@ namespace Lucene.Net.Codecs
                                 // test whether the prefix part matches:
                                 byte[] termBytes = term.Bytes;
                                 int termBytesPos = currentFrame.prefix - lenInPrefix;
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => termBytesPos >= 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(termBytesPos >= 0);
                                 int termBytesPosEnd = currentFrame.prefix;
                                 while (termBytesPos < termBytesPosEnd)
                                 {
@@ -1430,7 +1430,7 @@ namespace Lucene.Net.Codecs
                         {
                             CopyTerm();
                             //if (DEBUG) System.out.println("      term match to state=" + state + "; return term=" + brToString(term));
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => savedStartTerm == null || term.CompareTo(savedStartTerm) > 0, () => "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
+                            if (Debugging.AssertsEnabled) Debugging.Assert(savedStartTerm == null || term.CompareTo(savedStartTerm) > 0, () => "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
                             return term;
                         }
                         else
@@ -1534,7 +1534,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                     }
                     else
                     {
@@ -1582,7 +1582,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                     }
                     else
                     {
@@ -1617,7 +1617,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => lastFP == currentFrame.lastSubFP);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(lastFP == currentFrame.lastSubFP);
                                 // if (DEBUG) {
                                 //   System.out.println("  reset validIndexPrefix=" + validIndexPrefix);
                                 // }
@@ -1657,7 +1657,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                     }
                     else
                     {
@@ -1684,7 +1684,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => stack[ord].ord == ord);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1743,7 +1743,7 @@ namespace Lucene.Net.Codecs
                             //   System.out.println("        skip rewind!");
                             // }
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => length == f.prefix);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(length == f.prefix);
                     }
                     else
                     {
@@ -1789,7 +1789,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => ClearEOF());
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF());
 
                     FST.Arc<BytesRef> arc;
                     int targetUpto;
@@ -1811,12 +1811,12 @@ namespace Lucene.Net.Codecs
                         // }
 
                         arc = arcs[0];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => validIndexPrefix <= term.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -1840,7 +1840,7 @@ namespace Lucene.Net.Codecs
                             //if (arc.label != (target.bytes[target.offset + targetUpto] & 0xFF)) {
                             //System.out.println("FAIL: arc.label=" + (char) arc.label + " targetLabel=" + (char) (target.bytes[target.offset + targetUpto] & 0xFF));
                             //}
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -1907,7 +1907,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Length == target.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(term.Length == target.Length);
                             if (termExists)
                             {
                                 // if (DEBUG) {
@@ -1934,8 +1934,8 @@ namespace Lucene.Net.Codecs
                         // Empty string prefix must have an output (block) in the index!
                         if (Debugging.AssertsEnabled)
                         {
-                            Debugging.Assert(() => arc.IsFinal);
-                            Debugging.Assert(() => arc.Output != null);
+                            Debugging.Assert(arc.IsFinal);
+                            Debugging.Assert(arc.Output != null);
                         }
 
                         // if (DEBUG) {
@@ -2008,7 +2008,7 @@ namespace Lucene.Net.Codecs
                             arc = nextArc;
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             // Aggregate output as we go:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2076,7 +2076,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF());
 
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.seekCeil seg=" + segment + " target=" + fieldInfo.name + ":" + target.utf8ToString() + " " + target + " current=" + brToString(term) + " (exists?=" + termExists + ") validIndexPrefix=  " + validIndexPrefix);
@@ -2103,12 +2103,12 @@ namespace Lucene.Net.Codecs
                         //}
 
                         arc = arcs[0];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => validIndexPrefix <= term.Length);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -2129,7 +2129,7 @@ namespace Lucene.Net.Codecs
                                 break;
                             }
                             arc = arcs[1 + targetUpto];
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             // TOOD: we could save the outputs in local
                             // byte[][] instead of making new objs ever
                             // seek; but, often the FST doesn't have any
@@ -2198,7 +2198,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => term.Length == target.Length);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(term.Length == target.Length);
                             if (termExists)
                             {
                                 //if (DEBUG) {
@@ -2222,8 +2222,8 @@ namespace Lucene.Net.Codecs
                         // Empty string prefix must have an output (block) in the index!
                         if (Debugging.AssertsEnabled)
                         {
-                            Debugging.Assert(() => arc.IsFinal);
-                            Debugging.Assert(() => arc.Output != null);
+                            Debugging.Assert(arc.IsFinal);
+                            Debugging.Assert(arc.Output != null);
                         }
 
                         //if (DEBUG) {
@@ -2298,7 +2298,7 @@ namespace Lucene.Net.Codecs
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             arc = nextArc;
                             // Aggregate output as we go:
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.Output != null);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2431,7 +2431,7 @@ namespace Lucene.Net.Codecs
                         {
                             arc = outerInstance.index.GetFirstArc(arcs[0]);
                             // Empty string prefix must have an output in the index!
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => arc.IsFinal);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(arc.IsFinal);
                         }
                         else
                         {
@@ -2443,7 +2443,7 @@ namespace Lucene.Net.Codecs
 
                     targetBeforeCurrentLength = currentFrame.ord;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.next seg=" + segment + " term=" + brToString(term) + " termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);
                     //printSeekState();
@@ -2459,7 +2459,7 @@ namespace Lucene.Net.Codecs
                         // works properly:
                         //if (DEBUG) System.out.println("  re-seek to pending term=" + term.utf8ToString() + " " + term);
                         bool result = SeekExact(term);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => result);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(result);
                     }
 
                     // Pop finished blocks
@@ -2475,7 +2475,7 @@ namespace Lucene.Net.Codecs
                             if (currentFrame.ord == 0)
                             {
                                 //if (DEBUG) System.out.println("  return null");
-                                if (Debugging.AssertsEnabled) Debugging.Assert(SetEOF);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(SetEOF());
                                 term.Length = 0;
                                 validIndexPrefix = 0;
                                 currentFrame.Rewind();
@@ -2529,7 +2529,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                         return term;
                     }
                 }
@@ -2538,7 +2538,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                         //if (DEBUG) System.out.println("BTR.docFreq");
                         currentFrame.DecodeMetaData();
                         //if (DEBUG) System.out.println("  return " + currentFrame.state.docFreq);
@@ -2550,7 +2550,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                         currentFrame.DecodeMetaData();
                         return currentFrame.state.TotalTermFreq;
                     }
@@ -2558,7 +2558,7 @@ namespace Lucene.Net.Codecs
 
                 public override DocsEnum Docs(IBits skipDocs, DocsEnum reuse, DocsFlags flags)
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                     //if (DEBUG) {
                     //System.out.println("BTTR.docs seg=" + segment);
                     //}
@@ -2577,7 +2577,7 @@ namespace Lucene.Net.Codecs
                         return null;
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                     currentFrame.DecodeMetaData();
                     return outerInstance.outerInstance.postingsReader.DocsAndPositions(outerInstance.fieldInfo, currentFrame.state, skipDocs, reuse, flags);
                 }
@@ -2587,15 +2587,15 @@ namespace Lucene.Net.Codecs
                     // if (DEBUG) {
                     //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
                     // }
-                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(ClearEOF());
                     if (target.CompareTo(term) != 0 || !termExists)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => otherState != null && otherState is BlockTermState);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(otherState != null && otherState is BlockTermState);
                         currentFrame = staticFrame;
                         currentFrame.state.CopyFrom(otherState);
                         term.CopyBytes(target);
                         currentFrame.metaDataUpto = currentFrame.TermBlockOrd;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => currentFrame.metaDataUpto > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(currentFrame.metaDataUpto > 0);
                         validIndexPrefix = 0;
                     }
                     else
@@ -2608,7 +2608,7 @@ namespace Lucene.Net.Codecs
 
                 public override TermState GetTermState()
                 {
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => !eof);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(!eof);
                     currentFrame.DecodeMetaData();
                     TermState ts = (TermState)currentFrame.state.Clone();
                     //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
@@ -2740,7 +2740,7 @@ namespace Lucene.Net.Codecs
                         //if (DEBUG) {
                         //System.out.println("    loadNextFloorBlock fp=" + fp + " fpEnd=" + fpEnd);
                         //}
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == null || isFloor, () => "arc=" + arc + " isFloor=" + isFloor);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc == null || isFloor, () => "arc=" + arc + " isFloor=" + isFloor);
                         fp = fpEnd;
                         nextEnt = -1;
                         LoadBlock();
@@ -2774,9 +2774,9 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code >> 1);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => entCount > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(entCount > 0);
                         isLastInFloor = (code & 1) != 0;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => arc == null || (isLastInFloor || isFloor));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(arc == null || (isLastInFloor || isFloor));
 
                         // TODO: if suffixes were stored in random-access
                         // array structure, then we could do binary search
@@ -2897,7 +2897,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -2915,7 +2915,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -2974,7 +2974,7 @@ namespace Lucene.Net.Codecs
                             return;
                         }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => numFollowFloorBlocks != 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(numFollowFloorBlocks != 0);
 
                         long newFP = fpOrig;
                         while (true)
@@ -3034,7 +3034,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => limit > 0);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -3090,7 +3090,7 @@ namespace Lucene.Net.Codecs
                     /// </summary>
                     public void ScanToSubBlock(long subFP)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => !isLeafBlock);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(!isLeafBlock);
                         //if (DEBUG) System.out.println("  scanToSubBlock fp=" + fp + " subFP=" + subFP + " entCount=" + entCount + " lastSubFP=" + lastSubFP);
                         //assert nextEnt == 0;
                         if (lastSubFP == subFP)
@@ -3098,12 +3098,12 @@ namespace Lucene.Net.Codecs
                             //if (DEBUG) System.out.println("    already positioned");
                             return;
                         }
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => subFP < fp, () => "fp=" + fp + " subFP=" + subFP);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(subFP < fp, () => "fp=" + fp + " subFP=" + subFP);
                         long targetSubCode = fp - subFP;
                         //if (DEBUG) System.out.println("    targetSubCode=" + targetSubCode);
                         while (true)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt < entCount);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt < entCount);
                             nextEnt++;
                             int code = suffixesReader.ReadVInt32();
                             suffixesReader.SkipBytes(isLeafBlock ? code : (int)((uint)code >> 1));
@@ -3142,7 +3142,7 @@ namespace Lucene.Net.Codecs
                     {
                         // if (DEBUG) System.out.println("    scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1);
 
                         outerInstance.termExists = true;
                         subCode = 0;
@@ -3156,7 +3156,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => PrefixMatches(target));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3195,7 +3195,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => targetPos == targetLimit);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3251,7 +3251,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.termExists);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
@@ -3288,7 +3288,7 @@ namespace Lucene.Net.Codecs
                     {
                         //if (DEBUG) System.out.println("    scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => nextEnt != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(nextEnt != -1);
 
                         if (nextEnt == entCount)
                         {
@@ -3300,7 +3300,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => PrefixMatches(target));
+                        if (Debugging.AssertsEnabled) Debugging.Assert(PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3350,7 +3350,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => targetPos == targetLimit);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3407,7 +3407,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.termExists);
+                                    if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
index 7f5065a..43b9a9f 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
@@ -259,9 +259,9 @@ namespace Lucene.Net.Codecs
 
             public FieldMetaData(FieldInfo fieldInfo, BytesRef rootCode, long numTerms, long indexStartFP, long sumTotalTermFreq, long sumDocFreq, int docCount, int longsSize)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => numTerms > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(numTerms > 0);
                 this.FieldInfo = fieldInfo;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => rootCode != null, () => "field=" + fieldInfo.Name + " numTerms=" + numTerms);
+                if (Debugging.AssertsEnabled) Debugging.Assert(rootCode != null, () => "field=" + fieldInfo.Name + " numTerms=" + numTerms);
                 this.RootCode = rootCode;
                 this.IndexStartFP = indexStartFP;
                 this.NumTerms = numTerms;
@@ -368,14 +368,14 @@ namespace Lucene.Net.Codecs
         {
             //DEBUG = field.name.Equals("id", StringComparison.Ordinal);
             //if (DEBUG) System.out.println("\nBTTW.addField seg=" + segment + " field=" + field.name);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             return new TermsWriter(this, field);
         }
 
         internal static long EncodeOutput(long fp, bool hasTerms, bool isFloor)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => fp < (1L << 62));
+            if (Debugging.AssertsEnabled) Debugging.Assert(fp < (1L << 62));
             return (fp << 2) | (uint)(hasTerms ? OUTPUT_FLAG_HAS_TERMS : 0) | (uint)(isFloor ? OUTPUT_FLAG_IS_FLOOR : 0);
         }
 
@@ -481,10 +481,10 @@ namespace Lucene.Net.Codecs
                 // LUCENENET specific - we use a custom wrapper function to display floorBlocks, since
                 // it might contain garbage that cannot be converted into text.
                 if (Debugging.AssertsEnabled) Debugging.Assert(
-                    () => (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
+                    (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
                     () => "isFloor=" + IsFloor + " floorBlocks=" + ToString(floorBlocks));
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => scratchBytes.GetFilePointer() == 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(scratchBytes.GetFilePointer() == 0);
 
                 // TODO: try writing the leading vLong in MSB order
                 // (opposite of what Lucene does today), for better
@@ -495,12 +495,12 @@ namespace Lucene.Net.Codecs
                     scratchBytes.WriteVInt32(floorBlocks.Count);
                     foreach (PendingBlock sub in floorBlocks)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => sub.FloorLeadByte != -1);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(sub.FloorLeadByte != -1);
                         //if (DEBUG) {
                         //  System.out.println("    write floorLeadByte=" + Integer.toHexString(sub.floorLeadByte&0xff));
                         //}
                         scratchBytes.WriteByte((byte)(sbyte)sub.FloorLeadByte);
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => sub.Fp > Fp);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(sub.Fp > Fp);
                         scratchBytes.WriteVInt64((sub.Fp - Fp) << 1 | (uint)(sub.HasTerms ? 1 : 0));
                     }
                 }
@@ -508,7 +508,7 @@ namespace Lucene.Net.Codecs
                 ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton;
                 Builder<BytesRef> indexBuilder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE1, 0, 0, true, false, int.MaxValue, outputs, null, false, PackedInt32s.COMPACT, true, 15);
                 var bytes = new byte[(int)scratchBytes.GetFilePointer()];
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => bytes.Length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(bytes.Length > 0);
                 scratchBytes.WriteTo(bytes, 0);
                 indexBuilder.Add(Util.ToInt32sRef(Prefix, scratchIntsRef), new BytesRef(bytes, 0, bytes.Length));
                 scratchBytes.Reset();
@@ -729,8 +729,8 @@ namespace Lucene.Net.Codecs
                                 // in this block
                                 if (Debugging.AssertsEnabled)
                                 {
-                                    Debugging.Assert(() => lastSuffixLeadLabel == -1);
-                                    Debugging.Assert(() => numSubs == 0);
+                                    Debugging.Assert(lastSuffixLeadLabel == -1);
+                                    Debugging.Assert(numSubs == 0);
                                 }
                                 suffixLeadLabel = -1;
                             }
@@ -742,7 +742,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             PendingBlock block = (PendingBlock)ent;
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => block.Prefix.Length > prefixLength);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(block.Prefix.Length > prefixLength);
                             suffixLeadLabel = block.Prefix.Bytes[block.Prefix.Offset + prefixLength] & 0xff;
                         }
 
@@ -863,7 +863,7 @@ namespace Lucene.Net.Codecs
                             //System.out.println("    = " + pendingCount);
                             pendingCount = 0;
 
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => outerInstance.minItemsInBlock == 1 || subCount > 1, () => "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(outerInstance.minItemsInBlock == 1 || subCount > 1, () => "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
                             subCount = 0;
                             startLabel = subBytes[sub + 1];
 
@@ -880,8 +880,8 @@ namespace Lucene.Net.Codecs
                                 // here
                                 if (Debugging.AssertsEnabled)
                                 {
-                                    Debugging.Assert(() => startLabel != -1);
-                                    Debugging.Assert(() => firstBlock != null);
+                                    Debugging.Assert(startLabel != -1);
+                                    Debugging.Assert(firstBlock != null);
                                 }
                                 prevTerm.Int32s[prevTerm.Offset + prefixLength] = startLabel;
                                 //System.out.println("  final " + (numSubs-sub-1) + " subs");
@@ -902,7 +902,7 @@ namespace Lucene.Net.Codecs
 
                     prevTerm.Int32s[prevTerm.Offset + prefixLength] = savLabel;
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => firstBlock != null);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(firstBlock != null);
                     firstBlock.CompileIndex(floorBlocks, outerInstance.scratchBytes);
 
                     pending.Add(firstBlock);
@@ -931,11 +931,11 @@ namespace Lucene.Net.Codecs
             // block:
             private PendingBlock WriteBlock(Int32sRef prevTerm, int prefixLength, int indexPrefixLength, int startBackwards, int length, int futureTermCount, bool isFloor, int floorLeadByte, bool isLastInFloor)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => length > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(length > 0);
 
                 int start = pending.Count - startBackwards;
 
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => start >= 0, () => "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(start >= 0, () => "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
 
                 IList<PendingEntry> slice = pending.SubList(start, start + length);
 
@@ -994,7 +994,7 @@ namespace Lucene.Net.Codecs
                     subIndices = null;
                     foreach (PendingEntry ent in slice)
                     {
-                        if (Debugging.AssertsEnabled) Debugging.Assert(() => ent.IsTerm);
+                        if (Debugging.AssertsEnabled) Debugging.Assert(ent.IsTerm);
                         PendingTerm term = (PendingTerm)ent;
                         BlockTermState state = term.State;
                         int suffix = term.Term.Length - prefixLength;
@@ -1012,7 +1012,7 @@ namespace Lucene.Net.Codecs
                         statsWriter.WriteVInt32(state.DocFreq);
                         if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq, () => state.TotalTermFreq + " vs " + state.DocFreq);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(state.TotalTermFreq >= state.DocFreq, () => state.TotalTermFreq + " vs " + state.DocFreq);
                             statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                         }
 
@@ -1020,7 +1020,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                         for (int pos = 0; pos < longsSize; pos++)
                         {
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => longs[pos] >= 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(longs[pos] >= 0);
                             metaWriter.WriteVInt64(longs[pos]);
                         }
                         bytesWriter.WriteTo(metaWriter);
@@ -1055,7 +1055,7 @@ namespace Lucene.Net.Codecs
                             statsWriter.WriteVInt32(state.DocFreq);
                             if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(state.TotalTermFreq >= state.DocFreq);
                                 statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                             }
 
@@ -1071,7 +1071,7 @@ namespace Lucene.Net.Codecs
                             outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                             for (int pos = 0; pos < longsSize; pos++)
                             {
-                                if (Debugging.AssertsEnabled) Debugging.Assert(() => longs[pos] >= 0);
+                                if (Debugging.AssertsEnabled) Debugging.Assert(longs[pos] >= 0);
                                 metaWriter.WriteVInt64(longs[pos]);
                             }
                             bytesWriter.WriteTo(metaWriter);
@@ -1085,13 +1085,13 @@ namespace Lucene.Net.Codecs
                             PendingBlock block = (PendingBlock)ent;
                             int suffix = block.Prefix.Length - prefixLength;
 
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => suffix > 0);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(suffix > 0);
 
                             // For non-leaf block we borrow 1 bit to record
                             // if entry is term or sub-block
                             suffixWriter.WriteVInt32((suffix << 1) | 1);
                             suffixWriter.WriteBytes(block.Prefix.Bytes, prefixLength, suffix);
-                            if (Debugging.AssertsEnabled) Debugging.Assert(() => block.Fp < startFP);
+                            if (Debugging.AssertsEnabled) Debugging.Assert(block.Fp < startFP);
 
                             // if (DEBUG) {
                             //   BytesRef suffixBytes = new BytesRef(suffix);
@@ -1105,7 +1105,7 @@ namespace Lucene.Net.Codecs
                         }
                     }
 
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => subIndices.Count != 0);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(subIndices.Count != 0);
                 }
 
                 // TODO: we could block-write the term suffix pointers;
@@ -1184,7 +1184,7 @@ namespace Lucene.Net.Codecs
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => stats.DocFreq > 0);
+                if (Debugging.AssertsEnabled) Debugging.Assert(stats.DocFreq > 0);
                 //if (DEBUG) System.out.println("BTTW.finishTerm term=" + fieldInfo.name + ":" + toString(text) + " seg=" + segment + " df=" + stats.docFreq);
 
                 blockBuilder.Add(Util.ToInt32sRef(text, scratchIntsRef), noOutputs.NoOutput);
@@ -1206,12 +1206,12 @@ namespace Lucene.Net.Codecs
                     blockBuilder.Finish();
 
                     // We better have one final "root" block:
-                    if (Debugging.AssertsEnabled) Debugging.Assert(() => pending.Count == 1 && !pending[0].IsTerm, () => "pending.size()=" + pending.Count + " pending=" + pending);
+                    if (Debugging.AssertsEnabled) Debugging.Assert(pending.Count == 1 && !pending[0].IsTerm, () => "pending.size()=" + pending.Count + " pending=" + pending);
                     PendingBlock root = (PendingBlock)pending[0];
                     if (Debugging.AssertsEnabled)
                     {
-                        Debugging.Assert(() => root.Prefix.Length == 0);
-                        Debugging.Assert(() => root.Index.EmptyOutput != null);
+                        Debugging.Assert(root.Prefix.Length == 0);
+                        Debugging.Assert(root.Index.EmptyOutput != null);
                     }
 
                     this.sumTotalTermFreq = sumTotalTermFreq;
@@ -1237,9 +1237,9 @@ namespace Lucene.Net.Codecs
                 {
                     if (Debugging.AssertsEnabled)
                     {
-                        Debugging.Assert(() => sumTotalTermFreq == 0 || fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY && sumTotalTermFreq == -1);
-                        Debugging.Assert(() => sumDocFreq == 0);
-                        Debugging.Assert(() => docCount == 0);
+                        Debugging.Assert(sumTotalTermFreq == 0 || fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY && sumTotalTermFreq == -1);
+                        Debugging.Assert(sumDocFreq == 0);
+                        Debugging.Assert(docCount == 0);
                     }
                 }
             }
diff --git a/src/Lucene.Net/Codecs/CodecUtil.cs b/src/Lucene.Net/Codecs/CodecUtil.cs
index 66980d9..f78b5b9 100644
--- a/src/Lucene.Net/Codecs/CodecUtil.cs
+++ b/src/Lucene.Net/Codecs/CodecUtil.cs
@@ -268,7 +268,7 @@ namespace Lucene.Net.Codecs
             IndexInput clone = (IndexInput)input.Clone();
             clone.Seek(0);
             ChecksumIndexInput @in = new BufferedChecksumIndexInput(clone);
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => @in.GetFilePointer() == 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(@in.GetFilePointer() == 0);
             @in.Seek(@in.Length - FooterLength());
             return CheckFooter(@in);
         }
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
index a87b918..21b7f25 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
@@ -106,7 +106,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         private void WriteBlock()
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => blockChunks > 0);
+            if (Debugging.AssertsEnabled) Debugging.Assert(blockChunks > 0);
             fieldsIndexOut.WriteVInt32(blockChunks);
 
             // The trick here is that we only store the difference from the average start
@@ -144,7 +144,7 @@ namespace Lucene.Net.Codecs.Compressing
             for (int i = 0; i < blockChunks; ++i)
             {
                 long delta = docBase - avgChunkDocs * i;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
                 writer.Add(MoveSignToLowOrderBit(delta));
                 docBase += docBaseDeltas[i];
             }
@@ -179,7 +179,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 startPointer += startPointerDeltas[i];
                 long delta = startPointer - avgChunkSize * i;
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
+                if (Debugging.AssertsEnabled) Debugging.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
                 writer.Add(MoveSignToLowOrderBit(delta));
             }
             writer.Finish();
@@ -197,7 +197,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 firstStartPointer = maxStartPointer = startPointer;
             }
-            if (Debugging.AssertsEnabled) Debugging.Assert(() => firstStartPointer > 0 && startPointer >= firstStartPointer);
+            if (Debugging.AssertsEnabled) Debugging.Assert(firstStartPointer > 0 && startPointer >= firstStartPointer);
 
             docBaseDeltas[blockChunks] = numDocs;
             startPointerDeltas[blockChunks] = startPointer - maxStartPointer;
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
index b741c66..e657a6f 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.Compressing
                 indexStream = d.OpenChecksumInput(indexStreamFN, context);
                 string codecNameIdx = formatName + CompressingStoredFieldsWriter.CODEC_SFX_IDX;
                 version = CodecUtil.CheckHeader(indexStream, codecNameIdx, CompressingStoredFieldsWriter.VERSION_START, CompressingStoredFieldsWriter.VERSION_CURRENT);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
+                if (Debugging.AssertsEnabled) Debugging.Assert(CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
                 indexReader = new CompressingStoredFieldsIndexReader(indexStream, si);
 
                 long maxPointer = -1;
@@ -140,7 +140,7 @@ namespace Lucene.Net.Codecs.Compressing
                 {
                     throw new CorruptIndexException("Version mismatch between stored fields index and data: " + version + " != " + fieldsVersion);
                 }
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
+                if (Debugging.AssertsEnabled) Debugging.Assert(CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
 
                 if (version >= CompressingStoredFieldsWriter.VERSION_BIG_CHUNKS)
                 {
@@ -335,8 +335,8 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 if (Debugging.AssertsEnabled)
                 {
-                    Debugging.Assert(() => chunkSize > 0);
-                    Debugging.Assert(() => offset < chunkSize);
+                    Debugging.Assert(chunkSize > 0);
+                    Debugging.Assert(offset < chunkSize);
                 }
 
                 decompressor.Decompress(fieldsStream, chunkSize, offset, Math.Min(length, chunkSize - offset), bytes);
@@ -346,7 +346,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 BytesRef bytes = totalLength <= BUFFER_REUSE_THRESHOLD ? this.bytes : new BytesRef();
                 decompressor.Decompress(fieldsStream, totalLength, offset, length, bytes);
-                if (Debugging.AssertsEnabled) Debugging.Assert(() => bytes.Length == length);
+                if (Debugging.AssertsEnabled) Debugging.Assert(bytes.Length == length);
                 documentInput = new ByteArrayDataInput(bytes.Bytes, bytes.Offset, bytes.Length);
             }
 
@@ -357,7 +357,7 @@ namespace Lucene.Net.Codecs.Compressing
                 FieldInfo fieldInfo = fieldInfos.FieldInfo(fieldNumber);
 
                 int bits = (int)(infoAndBits & CompressingStoredFieldsWriter.TYPE_MASK);
... 11941 lines suppressed ...


[lucenenet] 01/13: Lucene.Net.Diagnostics: Moved AssertionException from test framework to Lucene.Net assembly

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit ee8d8e8c7dfc3ed3269bbe618584edd2b73d6fb8
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Thu Aug 13 04:16:44 2020 +0700

    Lucene.Net.Diagnostics: Moved AssertionException from test framework to Lucene.Net assembly
---
 .../Support/Diagnostics/AssertionException.cs                             | 0
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/Lucene.Net.TestFramework/Support/Diagnostics/AssertionException.cs b/src/Lucene.Net/Support/Diagnostics/AssertionException.cs
similarity index 100%
rename from src/Lucene.Net.TestFramework/Support/Diagnostics/AssertionException.cs
rename to src/Lucene.Net/Support/Diagnostics/AssertionException.cs


[lucenenet] 08/13: Lucene.Net.Diagnostics.Debugging: Changed AssertsEnabled to a static field

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 9caee944d5d1966d3dd5b63a7e1e7cd46169e164
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Wed Aug 19 05:17:56 2020 +0700

    Lucene.Net.Diagnostics.Debugging: Changed AssertsEnabled to a static field
---
 src/Lucene.Net/Support/Diagnostics/Debugging.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Lucene.Net/Support/Diagnostics/Debugging.cs b/src/Lucene.Net/Support/Diagnostics/Debugging.cs
index e4ce467..32ea1ea 100644
--- a/src/Lucene.Net/Support/Diagnostics/Debugging.cs
+++ b/src/Lucene.Net/Support/Diagnostics/Debugging.cs
@@ -34,7 +34,7 @@ namespace Lucene.Net.Diagnostics
         /// <see cref="Index.FreqProxTermsWriterPerField"/>, <see cref="Index.StoredFieldsProcessor"/>,
         /// <see cref="Index.TermVectorsConsumer"/>, and <see cref="Index.TermVectorsConsumerPerField"/>.
         /// </summary>
-        public static bool AssertsEnabled { get; set; } = SystemProperties.GetPropertyAsBoolean("assert", false);
+        public static bool AssertsEnabled = SystemProperties.GetPropertyAsBoolean("assert", false);
 
         ///// <summary>
         ///// Checks for a condition; if the condition is <c>false</c>, throws an <see cref="AssertionException"/>.


[lucenenet] 10/13: Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase: Fixed issue with reflection not finding the method due to the Func parameter of Debugging.Assert()

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit c3a53c31f5de1824f29c4543164f3f1e8766725f
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Sat Aug 22 14:00:48 2020 +0700

    Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase: Fixed issue with reflection not finding the method due to the Func<string> parameter of Debugging.Assert()
---
 .../Support/JavaCompatibility/LuceneTestCase.cs                      | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
index d2c7955..98f0f95 100644
--- a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
@@ -2,6 +2,7 @@ using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using JCG = J2N.Collections.Generic;
 
@@ -259,7 +260,9 @@ namespace Lucene.Net.Util
         [ExceptionToNetNumericConvention] // LUCENENET: This is for making test porting easier, keeping as-is
         internal int randomIntBetween(int min, int max)
         {
-            if (Debugging.AssertsEnabled) Debugging.Assert(max >= min, () => "max must be >= min: " + min + ", " + max);
+            // LUCENENET specific - added guard clause instead of assert
+            if (max < min)
+                throw new ArgumentOutOfRangeException(nameof(max), $"max must be >= min: {min}, {max}");
             long range = (long)max - (long)min;
             if (range < int.MaxValue)
             {


[lucenenet] 04/13: Converted test framework to use Lucene.Net.Diagnostics.Debugging.Assert() instead of Lucene.Net.Diagnostics.Debug.Assert()

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 8aa71088bd329e2c04e3e05eed8e069bc6812c98
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Thu Aug 13 23:09:25 2020 +0700

    Converted test framework to use Lucene.Net.Diagnostics.Debugging.Assert() instead of Lucene.Net.Diagnostics.Debug.Assert()
---
 .../Analysis/LookaheadTokenFilter.cs               |  24 +--
 .../Analysis/MockCharFilter.cs                     |   4 +-
 .../Analysis/MockReaderWrapper.cs                  |   8 +-
 .../Analysis/MockTokenizer.cs                      |  22 +-
 .../Codecs/Asserting/AssertingDocValuesFormat.cs   |  84 ++++----
 .../Codecs/Asserting/AssertingNormsFormat.cs       |   8 +-
 .../Codecs/Asserting/AssertingPostingsFormat.cs    |  70 +++----
 .../Asserting/AssertingStoredFieldsFormat.cs       |  22 +-
 .../Codecs/Asserting/AssertingTermVectorsFormat.cs |  48 ++---
 .../Compressing/Dummy/DummyCompressingCodec.cs     |   4 +-
 .../Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs   |   6 +-
 .../Codecs/Lucene3x/PreFlexRWFieldsWriter.cs       |  12 +-
 .../Codecs/Lucene3x/PreFlexRWNormsConsumer.cs      |   4 +-
 .../Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs |   6 +-
 .../Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs  |   8 +-
 .../Codecs/Lucene3x/TermInfosWriter.cs             |  14 +-
 .../Codecs/Lucene40/Lucene40DocValuesWriter.cs     |  18 +-
 .../Codecs/Lucene40/Lucene40FieldInfosWriter.cs    |  10 +-
 .../Codecs/Lucene40/Lucene40PostingsWriter.cs      |  18 +-
 .../Codecs/Lucene40/Lucene40SkipListWriter.cs      |  10 +-
 .../Codecs/Lucene42/Lucene42DocValuesConsumer.cs   |   4 +-
 .../Codecs/Lucene42/Lucene42FieldInfosWriter.cs    |   6 +-
 .../MockVariableIntBlockPostingsFormat.cs          |   4 +-
 .../Codecs/MockRandom/MockRandomPostingsFormat.cs  |   4 +-
 .../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs        |  12 +-
 .../Index/AllDeletedFilterReader.cs                |   4 +-
 .../Index/AssertingAtomicReader.cs                 | 224 ++++++++++-----------
 .../Index/BaseDocValuesFormatTestCase.cs           |  66 +++---
 .../Index/BasePostingsFormatTestCase.cs            |   4 +-
 .../Index/MockRandomMergePolicy.cs                 |   4 +-
 src/Lucene.Net.TestFramework/Index/RandomCodec.cs  |   6 +-
 .../Index/RandomDocumentsWriterPerThreadPool.cs    |  12 +-
 .../Index/RandomIndexWriter.cs                     |   4 +-
 .../Index/ThreadedIndexingAndSearchingTestCase.cs  |   6 +-
 .../Search/AssertingBulkScorer.cs                  |   4 +-
 .../Search/AssertingCollector.cs                   |   4 +-
 .../Search/AssertingScorer.cs                      |  10 +-
 src/Lucene.Net.TestFramework/Search/QueryUtils.cs  |   6 +-
 .../Search/RandomSimilarityProvider.cs             |   4 +-
 .../Search/ShardSearchingTestBase.cs               |  22 +-
 .../Store/MockDirectoryWrapper.cs                  |  12 +-
 .../Support/Diagnostics/Debug.cs                   |  46 -----
 .../Support/JavaCompatibility/LuceneTestCase.cs    |   4 +-
 .../Util/Automaton/AutomatonTestUtil.cs            |   6 +-
 .../Util/BaseDocIdSetTestCase.cs                   |   4 +-
 .../Util/FailOnNonBulkMergesInfoStream.cs          |   4 +-
 src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs |  10 +-
 .../Util/LuceneTestCase.cs                         |  16 +-
 .../Util/NullInfoStream.cs                         |   8 +-
 .../Util/TestRuleAssertionsRequired.cs             |   2 +-
 .../Util/TestRuleSetupAndRestoreClassEnv.cs        |  16 +-
 .../Util/ThrottledIndexOutput.cs                   |   4 +-
 52 files changed, 448 insertions(+), 494 deletions(-)

diff --git a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
index 262356c..67d081e 100644
--- a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
@@ -1,8 +1,8 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Analysis
 {
@@ -78,7 +78,7 @@ namespace Lucene.Net.Analysis
 
             public virtual AttributeSource.State NextState()
             {
-                Debug.Assert(NextRead < InputTokens.Count);
+                Debugging.Assert(() => NextRead < InputTokens.Count);
                 return InputTokens[NextRead++];
             }
         }
@@ -141,7 +141,7 @@ namespace Lucene.Net.Analysis
                 m_positions.Get(m_inputPos).Add(CaptureState());
                 tokenPending = false;
             }
-            Debug.Assert(!insertPending);
+            Debugging.Assert(() => !insertPending);
             insertPending = true;
         }
 
@@ -184,8 +184,8 @@ namespace Lucene.Net.Analysis
             {
                 Console.WriteLine("LTF.peekToken inputPos=" + m_inputPos + " outputPos=" + m_outputPos + " tokenPending=" + tokenPending);
             }
-            Debug.Assert(!m_end);
-            Debug.Assert(m_inputPos == -1 || m_outputPos <= m_inputPos);
+            Debugging.Assert(() => !m_end);
+            Debugging.Assert(() => m_inputPos == -1 || m_outputPos <= m_inputPos);
             if (tokenPending)
             {
                 m_positions.Get(m_inputPos).Add(CaptureState());
@@ -199,7 +199,7 @@ namespace Lucene.Net.Analysis
             if (gotToken)
             {
                 m_inputPos += m_posIncAtt.PositionIncrement;
-                Debug.Assert(m_inputPos >= 0);
+                Debugging.Assert(() => m_inputPos >= 0);
                 if (DEBUG)
                 {
                     Console.WriteLine("  now inputPos=" + m_inputPos);
@@ -216,7 +216,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    Debug.Assert(startPosData.StartOffset == startOffset, "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
+                    Debugging.Assert(() => startPosData.StartOffset == startOffset, () => "prev startOffset=" + startPosData.StartOffset + " vs new startOffset=" + startOffset + " inputPos=" + m_inputPos);
                 }
 
                 int endOffset = m_offsetAtt.EndOffset;
@@ -227,7 +227,7 @@ namespace Lucene.Net.Analysis
                 else
                 {
                     // Make sure our input isn't messing up offsets:
-                    Debug.Assert(endPosData.EndOffset == endOffset, "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
+                    Debugging.Assert(() => endPosData.EndOffset == endOffset, () => "prev endOffset=" + endPosData.EndOffset + " vs new endOffset=" + endOffset + " inputPos=" + m_inputPos);
                 }
 
                 tokenPending = true;
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            Debug.Assert(InsertedTokenConsistent());
+                            Debugging.Assert(InsertedTokenConsistent);
                             insertPending = false;
                             return true;
                         }
@@ -340,7 +340,7 @@ namespace Lucene.Net.Analysis
                             {
                                 Console.WriteLine("  return inserted token");
                             }
-                            Debug.Assert(InsertedTokenConsistent());
+                            Debugging.Assert(InsertedTokenConsistent);
                             insertPending = false;
                             return true;
                         }
@@ -364,8 +364,8 @@ namespace Lucene.Net.Analysis
         {
             int posLen = m_posLenAtt.PositionLength;
             Position endPosData = m_positions.Get(m_outputPos + posLen);
-            Debug.Assert(endPosData.EndOffset != -1);
-            Debug.Assert(m_offsetAtt.EndOffset == endPosData.EndOffset, "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
+            Debugging.Assert(() => endPosData.EndOffset != -1);
+            Debugging.Assert(() => m_offsetAtt.EndOffset == endPosData.EndOffset, () => "offsetAtt.endOffset=" + m_offsetAtt.EndOffset + " vs expected=" + endPosData.EndOffset);
             return true;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
index c4ad5f5..5f15220 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockCharFilter.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using JCG = J2N.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Analysis
 {
@@ -112,7 +112,7 @@ namespace Lucene.Net.Analysis
                 ret = currentOff;
             }
 
-            Debug.Assert(ret >= 0, "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
+            Debugging.Assert(() => ret >= 0, () => "currentOff=" + currentOff + ",diff=" + (ret - currentOff));
             return ret;
         }
 
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
index c16af6c..51e9e52 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockReaderWrapper.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.IO;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Analysis
 {
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis
         {
             excAtChar = charUpto;
             // You should only call this on init!:
-            Debug.Assert(0 == readSoFar);
+            Debugging.Assert(() => 0 == readSoFar);
         }
 
         public virtual void ThrowExcNext()
@@ -91,10 +91,10 @@ namespace Lucene.Net.Analysis
             if (excAtChar != -1)
             {
                 int left = excAtChar - readSoFar;
-                Debug.Assert(left != 0);
+                Debugging.Assert(() => left != 0);
                 read = input.Read(cbuf, off, Math.Min(realLen, left));
                 //Characters are left
-                Debug.Assert(read != 0);
+                Debugging.Assert(() => read != 0);
                 readSoFar += read;
             }
             else
diff --git a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
index 4be7f18..f2c076a 100644
--- a/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/MockTokenizer.cs
@@ -1,13 +1,13 @@
 using J2N;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
+using System.Globalization;
 using System.IO;
+using Assert = Lucene.Net.TestFramework.Assert;
 using CharacterRunAutomaton = Lucene.Net.Util.Automaton.CharacterRunAutomaton;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using RegExp = Lucene.Net.Util.Automaton.RegExp;
-using Assert = Lucene.Net.TestFramework.Assert;
-using System.Globalization;
 
 namespace Lucene.Net.Analysis
 {
@@ -140,7 +140,7 @@ namespace Lucene.Net.Analysis
 
         public sealed override bool IncrementToken()
         {
-            Debug.Assert(!enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), "IncrementToken() called while in wrong state: " + streamState);
+            Debugging.Assert(() => !enableChecks || (streamState == State.RESET || streamState == State.INCREMENT), () => "IncrementToken() called while in wrong state: " + streamState);
             ClearAttributes();
             for (; ; )
             {
@@ -219,7 +219,7 @@ namespace Lucene.Net.Analysis
             }
             else
             {
-                Debug.Assert(!char.IsLowSurrogate((char)ch), "unpaired low surrogate: " + ch.ToString("x"));
+                Debugging.Assert(() => !char.IsLowSurrogate((char)ch), () => "unpaired low surrogate: " + ch.ToString("x"));
                 off++;
                 if (char.IsHighSurrogate((char)ch))
                 {
@@ -227,12 +227,12 @@ namespace Lucene.Net.Analysis
                     if (ch2 >= 0)
                     {
                         off++;
-                        Debug.Assert(char.IsLowSurrogate((char)ch2), "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
+                        Debugging.Assert(() => char.IsLowSurrogate((char)ch2), () => "unpaired high surrogate: " + ch.ToString("x") + ", followed by: " + ch2.ToString("x"));
                         return Character.ToCodePoint((char)ch, (char)ch2);
                     }
                     else
                     {
-                        Debug.Assert(false, "stream ends with unpaired high surrogate: " + ch.ToString("x"));
+                        Debugging.Assert(() => false, () => "stream ends with unpaired high surrogate: " + ch.ToString("x"));
                     }
                 }
                 return ch;
@@ -300,7 +300,7 @@ namespace Lucene.Net.Analysis
             state = runAutomaton.InitialState;
             lastOffset = off = 0;
             bufferedCodePoint = -1;
-            Debug.Assert(!enableChecks || streamState != State.RESET, "Double Reset()");
+            Debugging.Assert(() => !enableChecks || streamState != State.RESET, () => "Double Reset()");
             streamState = State.RESET;
         }
 
@@ -312,14 +312,14 @@ namespace Lucene.Net.Analysis
                 // in some exceptional cases (e.g. TestIndexWriterExceptions) a test can prematurely close()
                 // these tests should disable this check, by default we check the normal workflow.
                 // TODO: investigate the CachingTokenFilter "double-close"... for now we ignore this
-                Debug.Assert(!enableChecks || streamState == State.END || streamState == State.CLOSE, "Dispose() called in wrong state: " + streamState);
+                Debugging.Assert(() => !enableChecks || streamState == State.END || streamState == State.CLOSE, () => "Dispose() called in wrong state: " + streamState);
                 streamState = State.CLOSE;
             }
         }
 
         internal override bool SetReaderTestPoint()
         {
-            Debug.Assert(!enableChecks || streamState == State.CLOSE, "SetReader() called in wrong state: " + streamState);
+            Debugging.Assert(() => !enableChecks || streamState == State.CLOSE, () => "SetReader() called in wrong state: " + streamState);
             streamState = State.SETREADER;
             return true;
         }
@@ -333,7 +333,7 @@ namespace Lucene.Net.Analysis
             // these tests should disable this check (in general you should consume the entire stream)
             try
             {
-                Debug.Assert(!enableChecks || streamState == State.INCREMENT_FALSE, "End() called before IncrementToken() returned false!");
+                Debugging.Assert(() => !enableChecks || streamState == State.INCREMENT_FALSE, () => "End() called before IncrementToken() returned false!");
             }
             finally
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
index f63298d..6cad1fc 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingDocValuesFormat.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Codecs.Lucene45;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Asserting
 {
@@ -40,15 +40,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer FieldsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.FieldsConsumer(state);
-            Debug.Assert(consumer != null);
+            Debugging.Assert(() => consumer != null);
             return new AssertingDocValuesConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer FieldsProducer(SegmentReadState state)
         {
-            Debug.Assert(state.FieldInfos.HasDocValues);
+            Debugging.Assert(() => state.FieldInfos.HasDocValues);
             DocValuesProducer producer = @in.FieldsProducer(state);
-            Debug.Assert(producer != null);
+            Debugging.Assert(() => producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
 
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     count++;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddNumericField(field, values);
             }
@@ -80,10 +80,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (BytesRef b in values)
                 {
-                    Debug.Assert(b == null || b.IsValid());
+                    Debugging.Assert(() => b == null || b.IsValid());
                     count++;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, true);
                 @in.AddBinaryField(field, values);
             }
@@ -94,25 +94,25 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    Debug.Assert(b != null);
-                    Debug.Assert(b.IsValid());
+                    Debugging.Assert(() => b != null);
+                    Debugging.Assert(() => b.IsValid());
                     if (valueCount > 0)
                     {
-                        Debug.Assert(b.CompareTo(lastValue) > 0);
+                        Debugging.Assert(() => b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
                 }
-                Debug.Assert(valueCount <= maxDoc);
+                Debugging.Assert(() => valueCount <= maxDoc);
 
                 FixedBitSet seenOrds = new FixedBitSet(valueCount);
 
                 int count = 0;
                 foreach (long? v in docToOrd)
                 {
-                    Debug.Assert(v != null);
+                    Debugging.Assert(() => v != null);
                     int ord = (int)v.Value;
-                    Debug.Assert(ord >= -1 && ord < valueCount);
+                    Debugging.Assert(() => ord >= -1 && ord < valueCount);
                     if (ord >= 0)
                     {
                         seenOrds.Set(ord);
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Asserting
                     count++;
                 }
 
-                Debug.Assert(count == maxDoc);
-                Debug.Assert(seenOrds.Cardinality() == valueCount);
+                Debugging.Assert(() => count == maxDoc);
+                Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
                 CheckIterator(values.GetEnumerator(), valueCount, false);
                 CheckIterator(docToOrd.GetEnumerator(), maxDoc, false);
                 @in.AddSortedField(field, values, docToOrd);
@@ -133,11 +133,11 @@ namespace Lucene.Net.Codecs.Asserting
                 BytesRef lastValue = null;
                 foreach (BytesRef b in values)
                 {
-                    Debug.Assert(b != null);
-                    Debug.Assert(b.IsValid());
+                    Debugging.Assert(() => b != null);
+                    Debugging.Assert(() => b.IsValid());
                     if (valueCount > 0)
                     {
-                        Debug.Assert(b.CompareTo(lastValue) > 0);
+                        Debugging.Assert(() => b.CompareTo(lastValue) > 0);
                     }
                     lastValue = BytesRef.DeepCopyOf(b);
                     valueCount++;
@@ -150,9 +150,9 @@ namespace Lucene.Net.Codecs.Asserting
                 {
                     foreach (long? v in docToOrdCount)
                     {
-                        Debug.Assert(v != null);
+                        Debugging.Assert(() => v != null);
                         int count = (int)v.Value;
-                        Debug.Assert(count >= 0);
+                        Debugging.Assert(() => count >= 0);
                         docCount++;
                         ordCount += count;
 
@@ -161,18 +161,18 @@ namespace Lucene.Net.Codecs.Asserting
                         {
                             ordIterator.MoveNext();
                             long? o = ordIterator.Current;
-                            Debug.Assert(o != null);
+                            Debugging.Assert(() => o != null);
                             long ord = o.Value;
-                            Debug.Assert(ord >= 0 && ord < valueCount);
-                            Debug.Assert(ord > lastOrd, "ord=" + ord + ",lastOrd=" + lastOrd);
+                            Debugging.Assert(() => ord >= 0 && ord < valueCount);
+                            Debugging.Assert(() => ord > lastOrd, () => "ord=" + ord + ",lastOrd=" + lastOrd);
                             seenOrds.Set(ord);
                             lastOrd = ord;
                         }
                     }
-                    Debug.Assert(ordIterator.MoveNext() == false);
+                    Debugging.Assert(() => ordIterator.MoveNext() == false);
 
-                    Debug.Assert(docCount == maxDoc);
-                    Debug.Assert(seenOrds.Cardinality() == valueCount);
+                    Debugging.Assert(() => docCount == maxDoc);
+                    Debugging.Assert(() => seenOrds.Cardinality() == valueCount);
                     CheckIterator(values.GetEnumerator(), valueCount, false);
                     CheckIterator(docToOrdCount.GetEnumerator(), maxDoc, false);
                     CheckIterator(ords.GetEnumerator(), ordCount, false);
@@ -203,10 +203,10 @@ namespace Lucene.Net.Codecs.Asserting
                 int count = 0;
                 foreach (long? v in values)
                 {
-                    Debug.Assert(v != null);
+                    Debugging.Assert(() => v != null);
                     count++;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
                 CheckIterator(values.GetEnumerator(), maxDoc, false);
                 @in.AddNumericField(field, values);
             }
@@ -240,9 +240,9 @@ namespace Lucene.Net.Codecs.Asserting
                 for (long i = 0; i < expectedSize; i++)
                 {
                     bool hasNext = iterator.MoveNext();
-                    Debug.Assert(hasNext);
+                    Debugging.Assert(() => hasNext);
                     T v = iterator.Current;
-                    Debug.Assert(allowNull || v != null);
+                    Debugging.Assert(() => allowNull || v != null);
 
                     // LUCENE.NET specific. removed call to Reset().
                     //try
@@ -255,7 +255,7 @@ namespace Lucene.Net.Codecs.Asserting
                     //    // ok
                     //}
                 }
-                Debug.Assert(!iterator.MoveNext());
+                Debugging.Assert(() => !iterator.MoveNext());
                 /*try
                 {
                   //iterator.next();
@@ -285,42 +285,42 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override NumericDocValues GetNumeric(FieldInfo field)
             {
-                Debug.Assert(field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC || field.NormType == DocValuesType.NUMERIC);
                 NumericDocValues values = @in.GetNumeric(field);
-                Debug.Assert(values != null);
+                Debugging.Assert(() => values != null);
                 return new AssertingNumericDocValues(values, maxDoc);
             }
 
             public override BinaryDocValues GetBinary(FieldInfo field)
             {
-                Debug.Assert(field.DocValuesType == DocValuesType.BINARY);
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
                 BinaryDocValues values = @in.GetBinary(field);
-                Debug.Assert(values != null);
+                Debugging.Assert(() => values != null);
                 return new AssertingBinaryDocValues(values, maxDoc);
             }
 
             public override SortedDocValues GetSorted(FieldInfo field)
             {
-                Debug.Assert(field.DocValuesType == DocValuesType.SORTED);
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
                 SortedDocValues values = @in.GetSorted(field);
-                Debug.Assert(values != null);
+                Debugging.Assert(() => values != null);
                 return new AssertingSortedDocValues(values, maxDoc);
             }
 
             public override SortedSetDocValues GetSortedSet(FieldInfo field)
             {
-                Debug.Assert(field.DocValuesType == DocValuesType.SORTED_SET);
+                Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
                 SortedSetDocValues values = @in.GetSortedSet(field);
-                Debug.Assert(values != null);
+                Debugging.Assert(() => values != null);
                 return new AssertingSortedSetDocValues(values, maxDoc);
             }
 
             public override IBits GetDocsWithField(FieldInfo field)
             {
-                Debug.Assert(field.DocValuesType != DocValuesType.NONE);
+                Debugging.Assert(() => field.DocValuesType != DocValuesType.NONE);
                 IBits bits = @in.GetDocsWithField(field);
-                Debug.Assert(bits != null);
-                Debug.Assert(bits.Length == maxDoc);
+                Debugging.Assert(() => bits != null);
+                Debugging.Assert(() => bits.Length == maxDoc);
                 return new AssertingBits(bits);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
index 28f822a..87efcba 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingNormsFormat.cs
@@ -1,7 +1,7 @@
 using Lucene.Net.Codecs.Lucene42;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using static Lucene.Net.Codecs.Asserting.AssertingDocValuesFormat;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Asserting
 {
@@ -32,15 +32,15 @@ namespace Lucene.Net.Codecs.Asserting
         public override DocValuesConsumer NormsConsumer(SegmentWriteState state)
         {
             DocValuesConsumer consumer = @in.NormsConsumer(state);
-            Debug.Assert(consumer != null);
+            Debugging.Assert(() => consumer != null);
             return new AssertingNormsConsumer(consumer, state.SegmentInfo.DocCount);
         }
 
         public override DocValuesProducer NormsProducer(SegmentReadState state)
         {
-            Debug.Assert(state.FieldInfos.HasNorms);
+            Debugging.Assert(() => state.FieldInfos.HasNorms);
             DocValuesProducer producer = @in.NormsProducer(state);
-            Debug.Assert(producer != null);
+            Debugging.Assert(() => producer != null);
             return new AssertingDocValuesProducer(producer, state.SegmentInfo.DocCount);
         }
     }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
index d12c609..cc99fd3 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingPostingsFormat.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Codecs.Lucene41;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Asserting
 {
@@ -67,7 +67,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override IEnumerator<string> GetEnumerator()
             {
                 IEnumerator<string> iterator = @in.GetEnumerator();
-                Debug.Assert(iterator != null);
+                Debugging.Assert(() => iterator != null);
                 return iterator;
             }
 
@@ -105,7 +105,7 @@ namespace Lucene.Net.Codecs.Asserting
             public override TermsConsumer AddField(FieldInfo field)
             {
                 TermsConsumer consumer = @in.AddField(field);
-                Debug.Assert(consumer != null);
+                Debugging.Assert(() => consumer != null);
                 return new AssertingTermsConsumer(consumer, field);
             }
 
@@ -144,28 +144,28 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override PostingsConsumer StartTerm(BytesRef text)
             {
-                Debug.Assert(state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.START;
-                Debug.Assert(lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
+                Debugging.Assert(() => lastTerm == null || @in.Comparer.Compare(text, lastTerm) > 0);
                 lastTerm = BytesRef.DeepCopyOf(text);
                 return lastPostingsConsumer = new AssertingPostingsConsumer(@in.StartTerm(text), fieldInfo, visitedDocs);
             }
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debug.Assert(state == TermsConsumerState.START);
+                Debugging.Assert(() => state == TermsConsumerState.START);
                 state = TermsConsumerState.INITIAL;
-                Debug.Assert(text.Equals(lastTerm));
-                Debug.Assert(stats.DocFreq > 0); // otherwise, this method should not be called.
-                Debug.Assert(stats.DocFreq == lastPostingsConsumer.docFreq);
+                Debugging.Assert(() => text.Equals(lastTerm));
+                Debugging.Assert(() => stats.DocFreq > 0); // otherwise, this method should not be called.
+                Debugging.Assert(() => stats.DocFreq == lastPostingsConsumer.docFreq);
                 sumDocFreq += stats.DocFreq;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debug.Assert(stats.TotalTermFreq == -1);
+                    Debugging.Assert(() => stats.TotalTermFreq == -1);
                 }
                 else
                 {
-                    Debug.Assert(stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
+                    Debugging.Assert(() => stats.TotalTermFreq == lastPostingsConsumer.totalTermFreq);
                     sumTotalTermFreq += stats.TotalTermFreq;
                 }
                 @in.FinishTerm(text, stats);
@@ -173,20 +173,20 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(long sumTotalTermFreq, long sumDocFreq, int docCount)
             {
-                Debug.Assert(state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
+                Debugging.Assert(() => state == TermsConsumerState.INITIAL || state == TermsConsumerState.START && lastPostingsConsumer.docFreq == 0);
                 state = TermsConsumerState.FINISHED;
-                Debug.Assert(docCount >= 0);
-                Debug.Assert(docCount == visitedDocs.Cardinality());
-                Debug.Assert(sumDocFreq >= docCount);
-                Debug.Assert(sumDocFreq == this.sumDocFreq);
+                Debugging.Assert(() => docCount >= 0);
+                Debugging.Assert(() => docCount == visitedDocs.Cardinality());
+                Debugging.Assert(() => sumDocFreq >= docCount);
+                Debugging.Assert(() => sumDocFreq == this.sumDocFreq);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debug.Assert(sumTotalTermFreq == -1);
+                    Debugging.Assert(() => sumTotalTermFreq == -1);
                 }
                 else
                 {
-                    Debug.Assert(sumTotalTermFreq >= sumDocFreq);
-                    Debug.Assert(sumTotalTermFreq == this.sumTotalTermFreq);
+                    Debugging.Assert(() => sumTotalTermFreq >= sumDocFreq);
+                    Debugging.Assert(() => sumTotalTermFreq == this.sumTotalTermFreq);
                 }
                 @in.Finish(sumTotalTermFreq, sumDocFreq, docCount);
             }
@@ -222,17 +222,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDoc(int docID, int freq)
             {
-                Debug.Assert(state == PostingsConsumerState.INITIAL);
+                Debugging.Assert(() => state == PostingsConsumerState.INITIAL);
                 state = PostingsConsumerState.START;
-                Debug.Assert(docID >= 0);
+                Debugging.Assert(() => docID >= 0);
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY)
                 {
-                    Debug.Assert(freq == -1);
+                    Debugging.Assert(() => freq == -1);
                     this.freq = 0; // we don't expect any positions here
                 }
                 else
                 {
-                    Debug.Assert(freq > 0);
+                    Debugging.Assert(() => freq > 0);
                     this.freq = freq;
                     totalTermFreq += freq;
                 }
@@ -246,41 +246,41 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                Debug.Assert(state == PostingsConsumerState.START);
-                Debug.Assert(positionCount < freq);
+                Debugging.Assert(() => state == PostingsConsumerState.START);
+                Debugging.Assert(() => positionCount < freq);
                 positionCount++;
-                Debug.Assert(position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
+                Debugging.Assert(() => position >= lastPosition || position == -1); // we still allow -1 from old 3.x indexes
                 lastPosition = position;
                 if (fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS)
                 {
-                    Debug.Assert(startOffset >= 0);
-                    Debug.Assert(startOffset >= lastStartOffset);
+                    Debugging.Assert(() => startOffset >= 0);
+                    Debugging.Assert(() => startOffset >= lastStartOffset);
                     lastStartOffset = startOffset;
-                    Debug.Assert(endOffset >= startOffset);
+                    Debugging.Assert(() => endOffset >= startOffset);
                 }
                 else
                 {
-                    Debug.Assert(startOffset == -1);
-                    Debug.Assert(endOffset == -1);
+                    Debugging.Assert(() => startOffset == -1);
+                    Debugging.Assert(() => endOffset == -1);
                 }
                 if (payload != null)
                 {
-                    Debug.Assert(fieldInfo.HasPayloads);
+                    Debugging.Assert(() => fieldInfo.HasPayloads);
                 }
                 @in.AddPosition(position, payload, startOffset, endOffset);
             }
 
             public override void FinishDoc()
             {
-                Debug.Assert(state == PostingsConsumerState.START);
+                Debugging.Assert(() => state == PostingsConsumerState.START);
                 state = PostingsConsumerState.INITIAL;
                 if (fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0)
                 {
-                    Debug.Assert(positionCount == 0); // we should not have fed any positions!
+                    Debugging.Assert(() => positionCount == 0); // we should not have fed any positions!
                 }
                 else
                 {
-                    Debug.Assert(positionCount == freq);
+                    Debugging.Assert(() => positionCount == freq);
                 }
                 @in.FinishDoc();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
index 3e87039..ca57617 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingStoredFieldsFormat.cs
@@ -1,7 +1,7 @@
 using Lucene.Net.Codecs.Lucene41;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Asserting
 {
@@ -58,7 +58,7 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void VisitDocument(int n, StoredFieldVisitor visitor)
             {
-                Debug.Assert(n >= 0 && n < maxDoc);
+                Debugging.Assert(() => n >= 0 && n < maxDoc);
                 @in.VisitDocument(n, visitor);
             }
 
@@ -100,9 +100,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numStoredFields)
             {
-                Debug.Assert(docStatus != Status.STARTED);
+                Debugging.Assert(() => docStatus != Status.STARTED);
                 @in.StartDocument(numStoredFields);
-                Debug.Assert(fieldCount == 0);
+                Debugging.Assert(() => fieldCount == 0);
                 fieldCount = numStoredFields;
                 numWritten++;
                 docStatus = Status.STARTED;
@@ -110,17 +110,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                Debug.Assert(docStatus == Status.STARTED);
-                Debug.Assert(fieldCount == 0);
+                Debugging.Assert(() => docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldCount == 0);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void WriteField(FieldInfo info, IIndexableField field)
             {
-                Debug.Assert(docStatus == Status.STARTED);
+                Debugging.Assert(() => docStatus == Status.STARTED);
                 @in.WriteField(info, field);
-                Debug.Assert(fieldCount > 0);
+                Debugging.Assert(() => fieldCount > 0);
                 fieldCount--;
             }
 
@@ -131,10 +131,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                Debug.Assert(docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
                 @in.Finish(fis, numDocs);
-                Debug.Assert(fieldCount == 0);
-                Debug.Assert(numDocs == numWritten);
+                Debugging.Assert(() => fieldCount == 0);
+                Debugging.Assert(() => numDocs == numWritten);
             }
 
             protected override void Dispose(bool disposing)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
index 0e735e6..10a94d5 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Asserting/AssertingTermVectorsFormat.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Codecs.Lucene40;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Asserting
 {
@@ -103,8 +103,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartDocument(int numVectorFields)
             {
-                Debug.Assert(fieldCount == 0);
-                Debug.Assert(docStatus != Status.STARTED);
+                Debugging.Assert(() => fieldCount == 0);
+                Debugging.Assert(() => docStatus != Status.STARTED);
                 @in.StartDocument(numVectorFields);
                 docStatus = Status.STARTED;
                 fieldCount = numVectorFields;
@@ -113,17 +113,17 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishDocument()
             {
-                Debug.Assert(fieldCount == 0);
-                Debug.Assert(docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldCount == 0);
+                Debugging.Assert(() => docStatus == Status.STARTED);
                 @in.FinishDocument();
                 docStatus = Status.FINISHED;
             }
 
             public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
             {
-                Debug.Assert(termCount == 0);
-                Debug.Assert(docStatus == Status.STARTED);
-                Debug.Assert(fieldStatus != Status.STARTED);
+                Debugging.Assert(() => termCount == 0);
+                Debugging.Assert(() => docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldStatus != Status.STARTED);
                 @in.StartField(info, numTerms, positions, offsets, payloads);
                 fieldStatus = Status.STARTED;
                 termCount = numTerms;
@@ -132,8 +132,8 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishField()
             {
-                Debug.Assert(termCount == 0);
-                Debug.Assert(fieldStatus == Status.STARTED);
+                Debugging.Assert(() => termCount == 0);
+                Debugging.Assert(() => fieldStatus == Status.STARTED);
                 @in.FinishField();
                 fieldStatus = Status.FINISHED;
                 --fieldCount;
@@ -141,9 +141,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void StartTerm(BytesRef term, int freq)
             {
-                Debug.Assert(docStatus == Status.STARTED);
-                Debug.Assert(fieldStatus == Status.STARTED);
-                Debug.Assert(termStatus != Status.STARTED);
+                Debugging.Assert(() => docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldStatus == Status.STARTED);
+                Debugging.Assert(() => termStatus != Status.STARTED);
                 @in.StartTerm(term, freq);
                 termStatus = Status.STARTED;
                 positionCount = hasPositions ? freq : 0;
@@ -151,10 +151,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void FinishTerm()
             {
-                Debug.Assert(positionCount == 0);
-                Debug.Assert(docStatus == Status.STARTED);
-                Debug.Assert(fieldStatus == Status.STARTED);
-                Debug.Assert(termStatus == Status.STARTED);
+                Debugging.Assert(() => positionCount == 0);
+                Debugging.Assert(() => docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldStatus == Status.STARTED);
+                Debugging.Assert(() => termStatus == Status.STARTED);
                 @in.FinishTerm();
                 termStatus = Status.FINISHED;
                 --termCount;
@@ -162,9 +162,9 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
             {
-                Debug.Assert(docStatus == Status.STARTED);
-                Debug.Assert(fieldStatus == Status.STARTED);
-                Debug.Assert(termStatus == Status.STARTED);
+                Debugging.Assert(() => docStatus == Status.STARTED);
+                Debugging.Assert(() => fieldStatus == Status.STARTED);
+                Debugging.Assert(() => termStatus == Status.STARTED);
                 @in.AddPosition(position, startOffset, endOffset, payload);
                 --positionCount;
             }
@@ -176,10 +176,10 @@ namespace Lucene.Net.Codecs.Asserting
 
             public override void Finish(FieldInfos fis, int numDocs)
             {
-                Debug.Assert(docCount == numDocs);
-                Debug.Assert(docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
-                Debug.Assert(fieldStatus != Status.STARTED);
-                Debug.Assert(termStatus != Status.STARTED);
+                Debugging.Assert(() => docCount == numDocs);
+                Debugging.Assert(() => docStatus == (numDocs > 0 ? Status.FINISHED : Status.UNDEFINED));
+                Debugging.Assert(() => fieldStatus != Status.STARTED);
+                Debugging.Assert(() => termStatus != Status.STARTED);
                 @in.Finish(fis, numDocs);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
index ba2ebfb..dacda7f 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Compressing.Dummy
 {
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
         {
             public override void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes)
             {
-                Debug.Assert(offset + length <= originalLength);
+                Debugging.Assert(() => offset + length <= originalLength);
                 if (bytes.Bytes.Length < originalLength)
                 {
                     bytes.Bytes = new byte[ArrayUtil.Oversize(originalLength, 1)];
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
index 9cddcce..d46a3ad 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldInfosWriter.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene3x
 {
@@ -79,7 +79,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (fi.IsIndexed)
                     {
                         bits |= IS_INDEXED;
-                        Debug.Assert(fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
+                        Debugging.Assert(() => fi.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !fi.HasPayloads);
                         if (fi.IndexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= OMIT_TERM_FREQ_AND_POSITIONS;
@@ -103,7 +103,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         // only in RW case
                         output.WriteByte((byte)(sbyte)(fi.NormType == Index.DocValuesType.NONE ? 0 : 1));
                     }
-                    Debug.Assert(fi.Attributes == null); // not used or supported
+                    Debugging.Assert(() => fi.Attributes == null); // not used or supported
                 }
                 success = true;
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
index 5f43e53..5964172 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWFieldsWriter.cs
@@ -1,9 +1,9 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene3x
 {
@@ -81,7 +81,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override TermsConsumer AddField(FieldInfo field)
         {
-            Debug.Assert(field.Number != -1);
+            Debugging.Assert(() => field.Number != -1);
             if (field.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0)
             {
                 throw new NotSupportedException("this codec cannot index offsets");
@@ -164,7 +164,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                     lastDocID = docID;
 
-                    Debug.Assert(docID < outerInstance.outerInstance.totalNumDocs, "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
+                    Debugging.Assert(() => docID < outerInstance.outerInstance.totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + outerInstance.outerInstance.totalNumDocs);
 
                     if (outerInstance.omitTF)
                     {
@@ -188,9 +188,9 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                 public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
                 {
-                    Debug.Assert(outerInstance.outerInstance.proxOut != null);
-                    Debug.Assert(startOffset == -1);
-                    Debug.Assert(endOffset == -1);
+                    Debugging.Assert(() => outerInstance.outerInstance.proxOut != null);
+                    Debugging.Assert(() => startOffset == -1);
+                    Debugging.Assert(() => endOffset == -1);
                     //System.out.println("      w pos=" + position + " payl=" + payload);
                     int delta = position - lastPosition;
                     lastPosition = position;
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
index 4bf5dcf..6831153 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWNormsConsumer.cs
@@ -1,9 +1,9 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using AssertionError = Lucene.Net.Diagnostics.AssertionException;
 
 namespace Lucene.Net.Codecs.Lucene3x
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddNumericField(FieldInfo field, IEnumerable<long?> values)
         {
-            Debug.Assert(field.Number > lastFieldNumber, "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
+            Debugging.Assert(() => field.Number > lastFieldNumber, () => "writing norms fields out of order" + lastFieldNumber + " -> " + field.Number);
             foreach (var n in values)
             {
                 if (((sbyte)(byte)(long)n) < sbyte.MinValue || ((sbyte)(byte)(long)n) > sbyte.MaxValue)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
index 8eb4908..e7bd7d9 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWStoredFieldsWriter.cs
@@ -1,9 +1,9 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene3x
 {
@@ -36,7 +36,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public PreFlexRWStoredFieldsWriter(Directory directory, string segment, IOContext context)
         {
-            Debug.Assert(directory != null);
+            Debugging.Assert(() => directory != null);
             this.directory = directory;
             this.segment = segment;
 
@@ -188,7 +188,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         fieldsStream.WriteInt64(J2N.BitConversion.DoubleToInt64Bits(field.GetDoubleValue().Value));
                         break;
                     default:
-                        Debug.Assert(false);
+                        Debugging.Assert(() => false);
                         break;
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
index a173c04..1f8fb40 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsWriter.cs
@@ -1,10 +1,10 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene3x
 {
@@ -75,7 +75,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
         {
-            Debug.Assert(lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
+            Debugging.Assert(() => lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
             lastFieldName = info.Name;
             if (payloads)
             {
@@ -98,7 +98,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
             tvf.WriteByte((byte)bits);
 
-            Debug.Assert(fieldCount <= numVectorFields);
+            Debugging.Assert(() => fieldCount <= numVectorFields);
             if (fieldCount == numVectorFields)
             {
                 // last field of the document
@@ -148,7 +148,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            Debug.Assert(payload == null);
+            Debugging.Assert(() => payload == null);
             if (positions && offsets)
             {
                 // write position delta
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
index 9d72885..3030f4c 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/TermInfosWriter.cs
@@ -1,10 +1,10 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.IO;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Directory = Lucene.Net.Store.Directory;
 
 namespace Lucene.Net.Codecs.Lucene3x
@@ -135,7 +135,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 output.WriteInt32(indexInterval); // write indexInterval
                 output.WriteInt32(skipInterval); // write skipInterval
                 output.WriteInt32(maxSkipLevels); // write maxSkipLevels
-                Debug.Assert(InitUTF16Results());
+                Debugging.Assert(InitUTF16Results);
                 success = true;
             }
             finally
@@ -202,10 +202,10 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
 
             scratchBytes.CopyBytes(term);
-            Debug.Assert(lastTerm.Offset == 0);
+            Debugging.Assert(() => lastTerm.Offset == 0);
             UnicodeUtil.UTF8toUTF16(lastTerm.Bytes, 0, lastTerm.Length, utf16Result1);
 
-            Debug.Assert(scratchBytes.Offset == 0);
+            Debugging.Assert(() => scratchBytes.Offset == 0);
             UnicodeUtil.UTF8toUTF16(scratchBytes.Bytes, 0, scratchBytes.Length, utf16Result2);
 
             int len;
@@ -243,10 +243,10 @@ namespace Lucene.Net.Codecs.Lucene3x
         /// </summary>
         public void Add(int fieldNumber, BytesRef term, TermInfo ti)
         {
-            Debug.Assert(CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
+            Debugging.Assert(() => CompareToLastTerm(fieldNumber, term) < 0 || (isIndex && term.Length == 0 && lastTerm.Length == 0), () => "Terms are out of order: field=" + FieldName(fieldInfos, fieldNumber) + " (number " + fieldNumber + ")" + " lastField=" + FieldName(fieldInfos, lastFieldNumber) + " (number " + lastFieldNumber + ")" + " text=" + term.Utf8ToString() + " lastText=" + lastTerm.Utf8ToString());
 
-            Debug.Assert(ti.FreqPointer >= lastTi.FreqPointer, "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
-            Debug.Assert(ti.ProxPointer >= lastTi.ProxPointer, "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
+            Debugging.Assert(() => ti.FreqPointer >= lastTi.FreqPointer, () => "freqPointer out of order (" + ti.FreqPointer + " < " + lastTi.FreqPointer + ")");
+            Debugging.Assert(() => ti.ProxPointer >= lastTi.ProxPointer, () => "proxPointer out of order (" + ti.ProxPointer + " < " + lastTi.ProxPointer + ")");
 
             if (!isIndex && size % indexInterval == 0)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
index 0085aa2..cd00949 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40DocValuesWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -8,7 +9,6 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using JCG = J2N.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene40
 {
@@ -333,7 +333,7 @@ namespace Lucene.Net.Codecs.Lucene40
             index.WriteVInt64(maxAddress);
 
             int maxDoc = state.SegmentInfo.DocCount;
-            Debug.Assert(maxDoc != int.MaxValue); // unsupported by the 4.0 impl
+            Debugging.Assert(() => maxDoc != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -346,7 +346,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
             }
             // write sentinel
-            Debug.Assert(currentPosition == maxAddress);
+            Debugging.Assert(() => currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
         }
@@ -375,7 +375,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             /* ordinals */
             int valueCount = dictionary.Count;
-            Debug.Assert(valueCount > 0);
+            Debugging.Assert(() => valueCount > 0);
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
@@ -439,7 +439,7 @@ namespace Lucene.Net.Codecs.Lucene40
         // the little vint encoding used for var-deref
         private static void WriteVInt16(IndexOutput o, int i)
         {
-            Debug.Assert(i >= 0 && i <= short.MaxValue);
+            Debugging.Assert(() => i >= 0 && i <= short.MaxValue);
             if (i < 128)
             {
                 o.WriteByte((byte)(sbyte)i);
@@ -545,7 +545,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             index.WriteInt32(valueCount);
             int maxDoc = state.SegmentInfo.DocCount;
-            Debug.Assert(valueCount > 0);
+            Debugging.Assert(() => valueCount > 0);
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
@@ -578,7 +578,7 @@ namespace Lucene.Net.Codecs.Lucene40
             long maxAddress = data.GetFilePointer() - startPos;
             index.WriteInt64(maxAddress);
 
-            Debug.Assert(valueCount != int.MaxValue); // unsupported by the 4.0 impl
+            Debugging.Assert(() => valueCount != int.MaxValue); // unsupported by the 4.0 impl
 
             PackedInt32s.Writer w = PackedInt32s.GetWriter(index, valueCount + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
@@ -588,14 +588,14 @@ namespace Lucene.Net.Codecs.Lucene40
                 currentPosition += v.Length;
             }
             // write sentinel
-            Debug.Assert(currentPosition == maxAddress);
+            Debugging.Assert(() => currentPosition == maxAddress);
             w.Add(currentPosition);
             w.Finish();
 
             /* ordinals */
 
             int maxDoc = state.SegmentInfo.DocCount;
-            Debug.Assert(valueCount > 0);
+            Debugging.Assert(() => valueCount > 0);
             PackedInt32s.Writer ords = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
index ec1bdaf..a11809e 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40FieldInfosWriter.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene40
 {
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene40FieldInfosFormat.IS_INDEXED;
-                        Debug.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene40FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     // pack the DV types in one byte
                     byte dv = DocValuesByte(fi.DocValuesType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_DV_TYPE_KEY));
                     byte nrm = DocValuesByte(fi.NormType, fi.GetAttribute(Lucene40FieldInfosReader.LEGACY_NORM_TYPE_KEY));
-                    Debug.Assert((dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
@@ -113,12 +113,12 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             if (type == DocValuesType.NONE)
             {
-                Debug.Assert(legacyTypeAtt == null);
+                Debugging.Assert(() => legacyTypeAtt == null);
                 return 0;
             }
             else
             {
-                Debug.Assert(legacyTypeAtt != null);
+                Debugging.Assert(() => legacyTypeAtt != null);
                 //return (sbyte)LegacyDocValuesType.ordinalLookup[legacyTypeAtt];
                 return (byte)legacyTypeAtt.ToLegacyDocValuesType();
             }
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
index e597def..0cdfac0 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40PostingsWriter.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene40
 {
@@ -208,7 +208,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 skipListWriter.BufferSkip(df);
             }
 
-            Debug.Assert(docID < totalNumDocs, "docID=" + docID + " totalNumDocs=" + totalNumDocs);
+            Debugging.Assert(() => docID < totalNumDocs, () => "docID=" + docID + " totalNumDocs=" + totalNumDocs);
 
             lastDocID = docID;
             if (indexOptions == IndexOptions.DOCS_ONLY)
@@ -234,12 +234,12 @@ namespace Lucene.Net.Codecs.Lucene40
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
             //if (DEBUG) System.out.println("SPW:     addPos pos=" + position + " payload=" + (payload == null ? "null" : (payload.Length + " bytes")) + " proxFP=" + proxOut.getFilePointer());
-            Debug.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, "invalid indexOptions: " + indexOptions);
-            Debug.Assert(proxOut != null);
+            Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0, () => "invalid indexOptions: " + indexOptions);
+            Debugging.Assert(() => proxOut != null);
 
             int delta = position - lastPosition;
 
-            Debug.Assert(delta >= 0, "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
+            Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition); // not quite right (if pos=0 is repeated twice we don't catch it)
 
             lastPosition = position;
 
@@ -271,7 +271,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 // and the numbers aren't that much smaller anyways.
                 int offsetDelta = startOffset - lastOffset;
                 int offsetLength = endOffset - startOffset;
-                Debug.Assert(offsetDelta >= 0 && offsetLength >= 0, "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
+                Debugging.Assert(() => offsetDelta >= 0 && offsetLength >= 0, () => "startOffset=" + startOffset + ",lastOffset=" + lastOffset + ",endOffset=" + endOffset);
                 if (offsetLength != lastOffsetLength)
                 {
                     proxOut.WriteVInt32(offsetDelta << 1 | 1);
@@ -308,11 +308,11 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             StandardTermState state_ = (StandardTermState)state;
             // if (DEBUG) System.out.println("SPW: finishTerm seg=" + segment + " freqStart=" + freqStart);
-            Debug.Assert(state_.DocFreq > 0);
+            Debugging.Assert(() => state_.DocFreq > 0);
 
             // TODO: wasteful we are counting this (counting # docs
             // for this term) in two places?
-            Debug.Assert(state_.DocFreq == df);
+            Debugging.Assert(() => state_.DocFreq == df);
             state_.FreqStart = freqStart;
             state_.ProxStart = proxStart;
             if (df >= skipMinimum)
@@ -337,7 +337,7 @@ namespace Lucene.Net.Codecs.Lucene40
             @out.WriteVInt64(state_.FreqStart - lastState.FreqStart);
             if (state_.SkipOffset != -1)
             {
-                Debug.Assert(state_.SkipOffset > 0);
+                Debugging.Assert(() => state_.SkipOffset > 0);
                 @out.WriteVInt64(state_.SkipOffset);
             }
             if (indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
index 282f62f..f8b50ee 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40SkipListWriter.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene40
 {
@@ -67,8 +67,8 @@ namespace Lucene.Net.Codecs.Lucene40
         /// </summary>
         public virtual void SetSkipData(int doc, bool storePayloads, int payloadLength, bool storeOffsets, int offsetLength)
         {
-            Debug.Assert(storePayloads || payloadLength == -1);
-            Debug.Assert(storeOffsets || offsetLength == -1);
+            Debugging.Assert(() => storePayloads || payloadLength == -1);
+            Debugging.Assert(() => storeOffsets || offsetLength == -1);
             this.curDoc = doc;
             this.curStorePayloads = storePayloads;
             this.curPayloadLength = payloadLength;
@@ -120,8 +120,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
             if (curStorePayloads || curStoreOffsets)
             {
-                Debug.Assert(curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
-                Debug.Assert(curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
+                Debugging.Assert(() => curStorePayloads || curPayloadLength == lastSkipPayloadLength[level]);
+                Debugging.Assert(() => curStoreOffsets || curOffsetLength == lastSkipOffsetLength[level]);
 
                 if (curPayloadLength == lastSkipPayloadLength[level] && curOffsetLength == lastSkipOffsetLength[level])
                 {
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
index 58dcb64..9c87bf3 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -9,7 +10,6 @@ using System.IO;
 using JCG = J2N.Collections.Generic;
 using static Lucene.Net.Util.Fst.FST;
 using static Lucene.Net.Util.Packed.PackedInt32s;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene42
 {
@@ -125,7 +125,7 @@ namespace Lucene.Net.Codecs.Lucene42
 
                     ++count;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
             }
 
             if (uniqueValues != null)
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
index 5a1d1b0..9889f63 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42FieldInfosWriter.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.Lucene42
 {
@@ -66,7 +66,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene42FieldInfosFormat.IS_INDEXED;
-                        Debug.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene42FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -87,7 +87,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     // pack the DV types in one byte
                     var dv = DocValuesByte(fi.DocValuesType);
                     var nrm = DocValuesByte(fi.NormType);
-                    Debug.Assert((dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteStringStringMap(fi.Attributes);
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
index e8b6cce..d8e4ed8 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -1,10 +1,10 @@
 using Lucene.Net.Codecs.BlockTerms;
 using Lucene.Net.Codecs.IntBlock;
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.MockIntBlock
 {
@@ -107,7 +107,7 @@ namespace Lucene.Net.Codecs.MockIntBlock
                     {
                         buffer[0] = input.ReadVInt32();
                         int count = buffer[0] <= 3 ? baseBlockSize - 1 : 2 * baseBlockSize - 1;
-                        Debug.Assert(buffer.Length >= count, "buffer.length=" + buffer.Length + " count=" + count);
+                        Debugging.Assert(() => buffer.Length >= count, () => "buffer.length=" + buffer.Length + " count=" + count);
                         for (int i = 0; i < count; i++)
                         {
                             buffer[i + 1] = input.ReadVInt32();
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
index ab3e43c..75925c1 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
@@ -5,13 +5,13 @@ using Lucene.Net.Codecs.MockIntBlock;
 using Lucene.Net.Codecs.MockSep;
 using Lucene.Net.Codecs.Pulsing;
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.MockRandom
 {
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.MockRandom
             private static string GetExtension(string fileName)
             {
                 int idx = fileName.IndexOf('.');
-                Debug.Assert(idx != -1);
+                Debugging.Assert(() => idx != -1);
                 return fileName.Substring(idx);
             }
 
diff --git a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
index 75eeebc..d4565c2 100644
--- a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
@@ -1,5 +1,6 @@
 using J2N.Text;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -7,7 +8,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using JCG = J2N.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Codecs.RAMOnly
 {
@@ -290,8 +290,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debug.Assert(stats.DocFreq > 0);
-                Debug.Assert(stats.DocFreq == current.docs.Count);
+                Debugging.Assert(() => stats.DocFreq > 0);
+                Debugging.Assert(() => stats.DocFreq == current.docs.Count);
                 current.totalTermFreq = stats.TotalTermFreq;
                 field.termToDocs[current.term] = current;
             }
@@ -324,8 +324,8 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
             {
-                Debug.Assert(startOffset == -1);
-                Debug.Assert(endOffset == -1);
+                Debugging.Assert(() => startOffset == -1);
+                Debugging.Assert(() => endOffset == -1);
                 current.positions[posUpto] = position;
                 if (payload != null && payload.Length > 0)
                 {
@@ -341,7 +341,7 @@ namespace Lucene.Net.Codecs.RAMOnly
 
             public override void FinishDoc()
             {
-                Debug.Assert(posUpto == current.positions.Length);
+                Debugging.Assert(() => posUpto == current.positions.Length);
             }
         }
 
diff --git a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
index d14e6c0..2c56376 100644
--- a/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AllDeletedFilterReader.cs
@@ -1,5 +1,5 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Index
 {
@@ -31,7 +31,7 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             liveDocs = new Bits.MatchNoBits(@in.MaxDoc);
-            Debug.Assert(MaxDoc == 0 || HasDeletions);
+            Debugging.Assert(() => MaxDoc == 0 || HasDeletions);
         }
 
         public override IBits LiveDocs => liveDocs;
diff --git a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
index 0183aac..4657a16 100644
--- a/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/AssertingAtomicReader.cs
@@ -1,9 +1,9 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Automaton;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Index
 {
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public override IEnumerator<string> GetEnumerator()
         {
             IEnumerator<string> iterator = base.GetEnumerator();
-            Debug.Assert(iterator != null);
+            Debugging.Assert(() => iterator != null);
             return iterator;
         }
 
@@ -59,8 +59,8 @@ namespace Lucene.Net.Index
         public override TermsEnum Intersect(CompiledAutomaton automaton, BytesRef bytes)
         {
             TermsEnum termsEnum = m_input.Intersect(automaton, bytes);
-            Debug.Assert(termsEnum != null);
-            Debug.Assert(bytes == null || bytes.IsValid());
+            Debugging.Assert(() => termsEnum != null);
+            Debugging.Assert(() => bytes == null || bytes.IsValid());
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
 
@@ -73,7 +73,7 @@ namespace Lucene.Net.Index
                 reuse = ((AssertingAtomicReader.AssertingTermsEnum)reuse).m_input;
             }
             TermsEnum termsEnum = base.GetIterator(reuse);
-            Debug.Assert(termsEnum != null);
+            Debugging.Assert(() => termsEnum != null);
             return new AssertingAtomicReader.AssertingTermsEnum(termsEnum);
         }
     }
@@ -102,7 +102,7 @@ namespace Lucene.Net.Index
             try
             {
                 int docid = @in.DocID;
-                Debug.Assert(docid == -1, @in.GetType() + ": invalid initial doc id: " + docid);
+                Debugging.Assert(() => docid == -1, () => @in.GetType() + ": invalid initial doc id: " + docid);
             }
             catch (NotSupportedException /*e*/)
             {
@@ -116,9 +116,9 @@ namespace Lucene.Net.Index
 
         public override int NextDoc()
         {
-            Debug.Assert(state != DocsEnumState.FINISHED, "NextDoc() called after NO_MORE_DOCS");
+            Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
             int nextDoc = base.NextDoc();
-            Debug.Assert(nextDoc > doc, "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
+            Debugging.Assert(() => nextDoc > doc, () => "backwards NextDoc from " + doc + " to " + nextDoc + " " + m_input);
             if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -127,16 +127,16 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            Debug.Assert(base.DocID == nextDoc);
+            Debugging.Assert(() => base.DocID == nextDoc);
             return doc = nextDoc;
         }
 
         public override int Advance(int target)
         {
-            Debug.Assert(state != DocsEnumState.FINISHED, "Advance() called after NO_MORE_DOCS");
-            Debug.Assert(target > doc, "target must be > DocID, got " + target + " <= " + doc);
+            Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+            Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
             int advanced = base.Advance(target);
-            Debug.Assert(advanced >= target, "backwards advance from: " + target + " to: " + advanced);
+            Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
             if (advanced == DocIdSetIterator.NO_MORE_DOCS)
             {
                 state = DocsEnumState.FINISHED;
@@ -145,7 +145,7 @@ namespace Lucene.Net.Index
             {
                 state = DocsEnumState.ITERATING;
             }
-            Debug.Assert(base.DocID == advanced);
+            Debugging.Assert(() => base.DocID == advanced);
             return doc = advanced;
         }
 
@@ -153,7 +153,7 @@ namespace Lucene.Net.Index
         {
             get
             {
-                Debug.Assert(doc == base.DocID, " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                 return doc;
             }
         }
@@ -162,10 +162,10 @@ namespace Lucene.Net.Index
         {
             get
             {
-                Debug.Assert(state != DocsEnumState.START, "Freq called before NextDoc()/Advance()");
-                Debug.Assert(state != DocsEnumState.FINISHED, "Freq called after NO_MORE_DOCS");
+                Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                 int freq = base.Freq;
-                Debug.Assert(freq > 0);
+                Debugging.Assert(() => freq > 0);
                 return freq;
             }
         }
@@ -186,7 +186,7 @@ namespace Lucene.Net.Index
 
         public override long Get(int docID)
         {
-            Debug.Assert(docID >= 0 && docID < maxDoc);
+            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
             return @in.Get(docID);
         }
     }
@@ -206,10 +206,10 @@ namespace Lucene.Net.Index
 
         public override void Get(int docID, BytesRef result)
         {
-            Debug.Assert(docID >= 0 && docID < maxDoc);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            Debugging.Assert(result.IsValid);
             @in.Get(docID, result);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(result.IsValid);
         }
     }
 
@@ -226,23 +226,23 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            Debug.Assert(valueCount >= 0 && valueCount <= maxDoc);
+            Debugging.Assert(() => valueCount >= 0 && valueCount <= maxDoc);
         }
 
         public override int GetOrd(int docID)
         {
-            Debug.Assert(docID >= 0 && docID < maxDoc);
+            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
             int ord = @in.GetOrd(docID);
-            Debug.Assert(ord >= -1 && ord < valueCount);
+            Debugging.Assert(() => ord >= -1 && ord < valueCount);
             return ord;
         }
 
         public override void LookupOrd(int ord, BytesRef result)
         {
-            Debug.Assert(ord >= 0 && ord < valueCount);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(() => ord >= 0 && ord < valueCount);
+            Debugging.Assert(result.IsValid);
             @in.LookupOrd(ord, result);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(result.IsValid);
         }
 
         public override int ValueCount
@@ -250,25 +250,25 @@ namespace Lucene.Net.Index
             get
             {
                 int valueCount = @in.ValueCount;
-                Debug.Assert(valueCount == this.valueCount); // should not change
+                Debugging.Assert(() => valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override void Get(int docID, BytesRef result)
         {
-            Debug.Assert(docID >= 0 && docID < maxDoc);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(() => docID >= 0 && docID < maxDoc);
+            Debugging.Assert(result.IsValid);
             @in.Get(docID, result);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(result.IsValid);
         }
 
         public override int LookupTerm(BytesRef key)
         {
-            Debug.Assert(key.IsValid());
+            Debugging.Assert(key.IsValid);
             int result = @in.LookupTerm(key);
-            Debug.Assert(result < valueCount);
-            Debug.Assert(key.IsValid());
+            Debugging.Assert(() => result < valueCount);
+            Debugging.Assert(key.IsValid);
             return result;
         }
     }
@@ -287,32 +287,32 @@ namespace Lucene.Net.Index
             this.@in = @in;
             this.maxDoc = maxDoc;
             this.valueCount = @in.ValueCount;
-            Debug.Assert(valueCount >= 0);
+            Debugging.Assert(() => valueCount >= 0);
         }
 
         public override long NextOrd()
         {
-            Debug.Assert(lastOrd != NO_MORE_ORDS);
+            Debugging.Assert(() => lastOrd != NO_MORE_ORDS);
             long ord = @in.NextOrd();
-            Debug.Assert(ord < valueCount);
-            Debug.Assert(ord == NO_MORE_ORDS || ord > lastOrd);
+            Debugging.Assert(() => ord < valueCount);
+            Debugging.Assert(() => ord == NO_MORE_ORDS || ord > lastOrd);
             lastOrd = ord;
             return ord;
         }
 
         public override void SetDocument(int docID)
         {
-            Debug.Assert(docID >= 0 && docID < maxDoc, "docid=" + docID + ",maxDoc=" + maxDoc);
+            Debugging.Assert(() => docID >= 0 && docID < maxDoc, () => "docid=" + docID + ",maxDoc=" + maxDoc);
             @in.SetDocument(docID);
             lastOrd = -2;
         }
 
         public override void LookupOrd(long ord, BytesRef result)
         {
-            Debug.Assert(ord >= 0 && ord < valueCount);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(() => ord >= 0 && ord < valueCount);
+            Debugging.Assert(result.IsValid);
             @in.LookupOrd(ord, result);
-            Debug.Assert(result.IsValid());
+            Debugging.Assert(result.IsValid);
         }
 
         public override long ValueCount
@@ -320,17 +320,17 @@ namespace Lucene.Net.Index
             get
             {
                 long valueCount = @in.ValueCount;
-                Debug.Assert(valueCount == this.valueCount); // should not change
+                Debugging.Assert(() => valueCount == this.valueCount); // should not change
                 return valueCount;
             }
         }
 
         public override long LookupTerm(BytesRef key)
         {
-            Debug.Assert(key.IsValid());
+            Debugging.Assert(key.IsValid);
             long result = @in.LookupTerm(key);
-            Debug.Assert(result < valueCount);
-            Debug.Assert(key.IsValid());
+            Debugging.Assert(() => result < valueCount);
+            Debugging.Assert(key.IsValid);
             return result;
         }
     }
@@ -348,7 +348,7 @@ namespace Lucene.Net.Index
 
         public virtual bool Get(int index)
         {
-            Debug.Assert(index >= 0 && index < Length);
+            Debugging.Assert(() => index >= 0 && index < Length);
             return @in.Get(index);
         }
 
@@ -365,10 +365,10 @@ namespace Lucene.Net.Index
             : base(@in)
         {
             // check some basic reader sanity
-            Debug.Assert(@in.MaxDoc >= 0);
-            Debug.Assert(@in.NumDocs <= @in.MaxDoc);
-            Debug.Assert(@in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
-            Debug.Assert(!@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
+            Debugging.Assert(() => @in.MaxDoc >= 0);
+            Debugging.Assert(() => @in.NumDocs <= @in.MaxDoc);
+            Debugging.Assert(() => @in.NumDeletedDocs + @in.NumDocs == @in.MaxDoc);
+            Debugging.Assert(() => !@in.HasDeletions || @in.NumDeletedDocs > 0 && @in.NumDocs < @in.MaxDoc);
         }
 
         public override Fields Fields
@@ -409,7 +409,7 @@ namespace Lucene.Net.Index
 
             public override DocsEnum Docs(IBits liveDocs, DocsEnum reuse, DocsFlags flags)
             {
-                Debug.Assert(state == State.POSITIONED, "Docs(...) called on unpositioned TermsEnum");
+                Debugging.Assert(() => state == State.POSITIONED, () => "Docs(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -423,7 +423,7 @@ namespace Lucene.Net.Index
 
             public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
             {
-                Debug.Assert(state == State.POSITIONED, "DocsAndPositions(...) called on unpositioned TermsEnum");
+                Debugging.Assert(() => state == State.POSITIONED, () => "DocsAndPositions(...) called on unpositioned TermsEnum");
 
                 // TODO: should we give this thing a random to be super-evil,
                 // and randomly *not* unwrap?
@@ -439,7 +439,7 @@ namespace Lucene.Net.Index
             // someone should not call next() after it returns null!!!!
             public override BytesRef Next()
             {
-                Debug.Assert(state == State.INITIAL || state == State.POSITIONED, "Next() called on unpositioned TermsEnum");
+                Debugging.Assert(() => state == State.INITIAL || state == State.POSITIONED, () => "Next() called on unpositioned TermsEnum");
                 BytesRef result = base.Next();
                 if (result == null)
                 {
@@ -447,7 +447,7 @@ namespace Lucene.Net.Index
                 }
                 else
                 {
-                    Debug.Assert(result.IsValid());
+                    Debugging.Assert(result.IsValid);
                     state = State.POSITIONED;
                 }
                 return result;
@@ -457,7 +457,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state == State.POSITIONED, "Ord called on unpositioned TermsEnum");
+                    Debugging.Assert(() => state == State.POSITIONED, () => "Ord called on unpositioned TermsEnum");
                     return base.Ord;
                 }
             }
@@ -466,7 +466,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state == State.POSITIONED, "DocFreq called on unpositioned TermsEnum");
+                    Debugging.Assert(() => state == State.POSITIONED, () => "DocFreq called on unpositioned TermsEnum");
                     return base.DocFreq;
                 }
             }
@@ -475,7 +475,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state == State.POSITIONED, "TotalTermFreq called on unpositioned TermsEnum");
+                    Debugging.Assert(() => state == State.POSITIONED, () => "TotalTermFreq called on unpositioned TermsEnum");
                     return base.TotalTermFreq;
                 }
             }
@@ -484,9 +484,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state == State.POSITIONED, "Term called on unpositioned TermsEnum");
+                    Debugging.Assert(() => state == State.POSITIONED, () => "Term called on unpositioned TermsEnum");
                     BytesRef ret = base.Term;
-                    Debug.Assert(ret == null || ret.IsValid());
+                    Debugging.Assert(() => ret == null || ret.IsValid());
                     return ret;
                 }
             }
@@ -499,7 +499,7 @@ namespace Lucene.Net.Index
 
             public override SeekStatus SeekCeil(BytesRef term)
             {
-                Debug.Assert(term.IsValid());
+                Debugging.Assert(term.IsValid);
                 SeekStatus result = base.SeekCeil(term);
                 if (result == SeekStatus.END)
                 {
@@ -514,7 +514,7 @@ namespace Lucene.Net.Index
 
             public override bool SeekExact(BytesRef text)
             {
-                Debug.Assert(text.IsValid());
+                Debugging.Assert(text.IsValid);
                 if (base.SeekExact(text))
                 {
                     state = State.POSITIONED;
@@ -529,13 +529,13 @@ namespace Lucene.Net.Index
 
             public override TermState GetTermState()
             {
-                Debug.Assert(state == State.POSITIONED, "GetTermState() called on unpositioned TermsEnum");
+                Debugging.Assert(() => state == State.POSITIONED, () => "GetTermState() called on unpositioned TermsEnum");
                 return base.GetTermState();
             }
 
             public override void SeekExact(BytesRef term, TermState state)
             {
-                Debug.Assert(term.IsValid());
+                Debugging.Assert(term.IsValid);
                 base.SeekExact(term, state);
                 this.state = State.POSITIONED;
             }
@@ -556,15 +556,15 @@ namespace Lucene.Net.Index
                 : base(@in)
             {
                 int docid = @in.DocID;
-                Debug.Assert(docid == -1, "invalid initial doc id: " + docid);
+                Debugging.Assert(() => docid == -1, () => "invalid initial doc id: " + docid);
                 doc = -1;
             }
 
             public override int NextDoc()
             {
-                Debug.Assert(state != DocsEnumState.FINISHED, "NextDoc() called after NO_MORE_DOCS");
+                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextDoc() called after NO_MORE_DOCS");
                 int nextDoc = base.NextDoc();
-                Debug.Assert(nextDoc > doc, "backwards nextDoc from " + doc + " to " + nextDoc);
+                Debugging.Assert(() => nextDoc > doc, () => "backwards nextDoc from " + doc + " to " + nextDoc);
                 positionCount = 0;
                 if (nextDoc == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -576,16 +576,16 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                Debug.Assert(base.DocID == nextDoc);
+                Debugging.Assert(() => base.DocID == nextDoc);
                 return doc = nextDoc;
             }
 
             public override int Advance(int target)
             {
-                Debug.Assert(state != DocsEnumState.FINISHED, "Advance() called after NO_MORE_DOCS");
-                Debug.Assert(target > doc, "target must be > DocID, got " + target + " <= " + doc);
+                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Advance() called after NO_MORE_DOCS");
+                Debugging.Assert(() => target > doc, () => "target must be > DocID, got " + target + " <= " + doc);
                 int advanced = base.Advance(target);
-                Debug.Assert(advanced >= target, "backwards advance from: " + target + " to: " + advanced);
+                Debugging.Assert(() => advanced >= target, () => "backwards advance from: " + target + " to: " + advanced);
                 positionCount = 0;
                 if (advanced == DocIdSetIterator.NO_MORE_DOCS)
                 {
@@ -597,7 +597,7 @@ namespace Lucene.Net.Index
                     state = DocsEnumState.ITERATING;
                     positionMax = base.Freq;
                 }
-                Debug.Assert(base.DocID == advanced);
+                Debugging.Assert(() => base.DocID == advanced);
                 return doc = advanced;
             }
 
@@ -605,7 +605,7 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(doc == base.DocID, " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
+                    Debugging.Assert(() => doc == base.DocID, () => " invalid DocID in " + m_input.GetType() + " " + base.DocID + " instead of " + doc);
                     return doc;
                 }
             }
@@ -614,21 +614,21 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state != DocsEnumState.START, "Freq called before NextDoc()/Advance()");
-                    Debug.Assert(state != DocsEnumState.FINISHED, "Freq called after NO_MORE_DOCS");
+                    Debugging.Assert(() => state != DocsEnumState.START, () => "Freq called before NextDoc()/Advance()");
+                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "Freq called after NO_MORE_DOCS");
                     int freq = base.Freq;
-                    Debug.Assert(freq > 0);
+                    Debugging.Assert(() => freq > 0);
                     return freq;
                 }
             }
 
             public override int NextPosition()
             {
-                Debug.Assert(state != DocsEnumState.START, "NextPosition() called before NextDoc()/Advance()");
-                Debug.Assert(state != DocsEnumState.FINISHED, "NextPosition() called after NO_MORE_DOCS");
-                Debug.Assert(positionCount < positionMax, "NextPosition() called more than Freq times!");
+                Debugging.Assert(() => state != DocsEnumState.START, () => "NextPosition() called before NextDoc()/Advance()");
+                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "NextPosition() called after NO_MORE_DOCS");
+                Debugging.Assert(() => positionCount < positionMax, () => "NextPosition() called more than Freq times!");
                 int position = base.NextPosition();
-                Debug.Assert(position >= 0 || position == -1, "invalid position: " + position);
+                Debugging.Assert(() => position >= 0 || position == -1, () => "invalid position: " + position);
                 positionCount++;
                 return position;
             }
@@ -637,9 +637,9 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state != DocsEnumState.START, "StartOffset called before NextDoc()/Advance()");
-                    Debug.Assert(state != DocsEnumState.FINISHED, "StartOffset called after NO_MORE_DOCS");
-                    Debug.Assert(positionCount > 0, "StartOffset called before NextPosition()!");
+                    Debugging.Assert(() => state != DocsEnumState.START, () => "StartOffset called before NextDoc()/Advance()");
+                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "StartOffset called after NO_MORE_DOCS");
+                    Debugging.Assert(() => positionCount > 0, () => "StartOffset called before NextPosition()!");
                     return base.StartOffset;
                 }
             }
@@ -648,20 +648,20 @@ namespace Lucene.Net.Index
             {
                 get
                 {
-                    Debug.Assert(state != DocsEnumState.START, "EndOffset called before NextDoc()/Advance()");
-                    Debug.Assert(state != DocsEnumState.FINISHED, "EndOffset called after NO_MORE_DOCS");
-                    Debug.Assert(positionCount > 0, "EndOffset called before NextPosition()!");
+                    Debugging.Assert(() => state != DocsEnumState.START, () => "EndOffset called before NextDoc()/Advance()");
+                    Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "EndOffset called after NO_MORE_DOCS");
+                    Debugging.Assert(() => positionCount > 0, () => "EndOffset called before NextPosition()!");
                     return base.EndOffset;
                 }
             }
 
             public override BytesRef GetPayload()
             {
-                Debug.Assert(state != DocsEnumState.START, "GetPayload() called before NextDoc()/Advance()");
-                Debug.Assert(state != DocsEnumState.FINISHED, "GetPayload() called after NO_MORE_DOCS");
-                Debug.Assert(positionCount > 0, "GetPayload() called before NextPosition()!");
+                Debugging.Assert(() => state != DocsEnumState.START, () => "GetPayload() called before NextDoc()/Advance()");
+                Debugging.Assert(() => state != DocsEnumState.FINISHED, () => "GetPayload() called after NO_MORE_DOCS");
+                Debugging.Assert(() => positionCount > 0, () => "GetPayload() called before NextPosition()!");
                 BytesRef payload = base.GetPayload();
-                Debug.Assert(payload == null || payload.IsValid() && payload.Length > 0, "GetPayload() returned payload with invalid length!");
+                Debugging.Assert(() => payload == null || payload.IsValid() && payload.Length > 0, () => "GetPayload() returned payload with invalid length!");
                 return payload;
             }
         }
@@ -681,13 +681,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.DocValuesType == DocValuesType.NUMERIC);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.DocValuesType == DocValuesType.NUMERIC);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                Debug.Assert(fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
+                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.NUMERIC);
                 return null;
             }
         }
@@ -698,13 +698,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.DocValuesType == DocValuesType.BINARY);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.DocValuesType == DocValuesType.BINARY);
                 return new AssertingBinaryDocValues(dv, MaxDoc);
             }
             else
             {
-                Debug.Assert(fi == null || fi.DocValuesType != DocValuesType.BINARY);
+                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.BINARY);
                 return null;
             }
         }
@@ -715,13 +715,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.DocValuesType == DocValuesType.SORTED);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED);
                 return new AssertingSortedDocValues(dv, MaxDoc);
             }
             else
             {
-                Debug.Assert(fi == null || fi.DocValuesType != DocValuesType.SORTED);
+                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED);
                 return null;
             }
         }
@@ -732,13 +732,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.DocValuesType == DocValuesType.SORTED_SET);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.DocValuesType == DocValuesType.SORTED_SET);
                 return new AssertingSortedSetDocValues(dv, MaxDoc);
             }
             else
             {
-                Debug.Assert(fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
+                Debugging.Assert(() => fi == null || fi.DocValuesType != DocValuesType.SORTED_SET);
                 return null;
             }
         }
@@ -749,13 +749,13 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (dv != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.HasNorms);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.HasNorms);
                 return new AssertingNumericDocValues(dv, MaxDoc);
             }
             else
             {
-                Debug.Assert(fi == null || fi.HasNorms == false);
+                Debugging.Assert(() => fi == null || fi.HasNorms == false);
                 return null;
             }
         }
@@ -769,13 +769,13 @@ namespace Lucene.Net.Index
                 IBits liveDocs = base.LiveDocs;
                 if (liveDocs != null)
                 {
-                    Debug.Assert(MaxDoc == liveDocs.Length);
+                    Debugging.Assert(() => MaxDoc == liveDocs.Length);
                     liveDocs = new AssertingBits(liveDocs);
                 }
                 else
                 {
-                    Debug.Assert(MaxDoc == NumDocs);
-                    Debug.Assert(!HasDeletions);
+                    Debugging.Assert(() => MaxDoc == NumDocs);
+                    Debugging.Assert(() => !HasDeletions);
                 }
                 return liveDocs;
             }
@@ -787,14 +787,14 @@ namespace Lucene.Net.Index
             FieldInfo fi = FieldInfos.FieldInfo(field);
             if (docsWithField != null)
             {
-                Debug.Assert(fi != null);
-                Debug.Assert(fi.HasDocValues);
-                Debug.Assert(MaxDoc == docsWithField.Length);
+                Debugging.Assert(() => fi != null);
+                Debugging.Assert(() => fi.HasDocValues);
+                Debugging.Assert(() => MaxDoc == docsWithField.Length);
                 docsWithField = new AssertingBits(docsWithField);
             }
             else
             {
-                Debug.Assert(fi == null || fi.HasDocValues == false);
+                Debugging.Assert(() => fi == null || fi.HasDocValues == false);
             }
             return docsWithField;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
index 1f58b28..0ba88c9 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
@@ -1,6 +1,7 @@
 using J2N.Threading;
 using Lucene.Net.Analysis;
 using Lucene.Net.Codecs.Lucene42;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
@@ -12,7 +13,6 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Threading;
 using JCG = J2N.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Assert = Lucene.Net.TestFramework.Assert;
 using static Lucene.Net.Index.TermsEnum;
 using J2N.Collections.Generic.Extensions;
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader))).GetNumericDocValues("dv");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                     }
@@ -159,7 +159,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv");
                         Assert.AreEqual((long)J2N.BitConversion.SingleToInt32Bits(5.7f), dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - cast required because types don't match (xUnit checks this)
                     }
@@ -201,7 +201,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv2");
@@ -248,7 +248,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv1");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef(longTerm), scratch);
@@ -297,7 +297,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         NumericDocValues dv = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetNumericDocValues("dv1");
                         Assert.AreEqual(5L, dv.Get(hits.ScoreDocs[i].Doc)); // LUCENENET specific - 5L required because types don't match (xUnit checks this)
                         BinaryDocValues dv2 = ((AtomicReader)((AtomicReader)ireader.Leaves[0].Reader)).GetBinaryDocValues("dv2");
@@ -346,7 +346,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv1");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -399,7 +399,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv2");
                         int ord = dv.GetOrd(0);
                         dv.LookupOrd(ord, scratch);
@@ -438,7 +438,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(1L, dv.Get(0)); // LUCENENET specific - 1L required because types don't match (xUnit checks this)
                     Assert.AreEqual(2L, dv.Get(1)); // LUCENENET specific - 2L required because types don't match (xUnit checks this)
@@ -473,7 +473,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     for (int i = 0; i < 2; i++)
                     {
@@ -517,7 +517,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(long.MinValue, dv.Get(0));
                     Assert.AreEqual(long.MaxValue, dv.Get(1));
@@ -549,7 +549,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv");
                     Assert.AreEqual(-8841491950446638677L, dv.Get(0));
                     Assert.AreEqual(9062230939892376225L, dv.Get(1));
@@ -591,7 +591,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                         dv.Get(hits.ScoreDocs[i].Doc, scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -627,7 +627,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     for (int i = 0; i < 2; i++)
@@ -684,7 +684,7 @@ namespace Lucene.Net.Index
                     {
                         Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                         Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                        Debug.Assert(ireader.Leaves.Count == 1);
+                        Debugging.Assert(() => ireader.Leaves.Count == 1);
                         SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                         dv.LookupOrd(dv.GetOrd(hits.ScoreDocs[i].Doc), scratch);
                         Assert.AreEqual(new BytesRef("hello world"), scratch);
@@ -717,7 +717,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -755,7 +755,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount);
                     BytesRef scratch = new BytesRef();
@@ -797,7 +797,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     Assert.AreEqual(2, dv.ValueCount); // 2 ords
                     BytesRef scratch = new BytesRef();
@@ -894,7 +894,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -925,7 +925,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.LookupOrd(dv.GetOrd(0), scratch);
@@ -1045,7 +1045,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     SortedDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     Assert.AreEqual(0, dv.GetOrd(0));
@@ -1080,7 +1080,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1114,7 +1114,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1146,7 +1146,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1174,7 +1174,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1205,7 +1205,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     var mybytes = new byte[20];
                     BytesRef scratch = new BytesRef(mybytes);
@@ -1239,7 +1239,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1277,7 +1277,7 @@ namespace Lucene.Net.Index
                 // Now search the index:
                 using (IndexReader ireader = DirectoryReader.Open(directory)) // read-only=true
                 {
-                    Debug.Assert(ireader.Leaves.Count == 1);
+                    Debugging.Assert(() => ireader.Leaves.Count == 1);
                     BinaryDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetSortedDocValues("dv");
                     BytesRef scratch = new BytesRef();
                     dv.Get(0, scratch);
@@ -1494,7 +1494,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    Debug.Assert(numDocs > 256);
+                    Debugging.Assert(() => numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -1580,7 +1580,7 @@ namespace Lucene.Net.Index
                     int numDocs = AtLeast(300);
                     // numDocs should be always > 256 so that in case of a codec that optimizes
                     // for numbers of values <= 256, all storage layouts are tested
-                    Debug.Assert(numDocs > 256);
+                    Debugging.Assert(() => numDocs > 256);
                     for (int i = 0; i < numDocs; i++)
                     {
                         idField.SetStringValue(Convert.ToString(i, CultureInfo.InvariantCulture));
@@ -2649,13 +2649,13 @@ namespace Lucene.Net.Index
                             }
                             for (int j = 0; j < stringValues.Length; j++)
                             {
-                                Debug.Assert(docValues != null);
+                                Debugging.Assert(() => docValues != null);
                                 long ord = docValues.NextOrd();
-                                Debug.Assert(ord != SortedSetDocValues.NO_MORE_ORDS);
+                                Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
                                 docValues.LookupOrd(ord, scratch);
                                 Assert.AreEqual(stringValues[j], scratch.Utf8ToString());
                             }
-                            Debug.Assert(docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
+                            Debugging.Assert(() => docValues == null || docValues.NextOrd() == SortedSetDocValues.NO_MORE_ORDS);
                         }
                     }
                 } // ir.Dispose();
diff --git a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
index f3f2791..de00107 100644
--- a/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BasePostingsFormatTestCase.cs
@@ -1,5 +1,6 @@
 using J2N.Threading;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -8,7 +9,6 @@ using System.Collections.Generic;
 using System.IO;
 using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Assert = Lucene.Net.TestFramework.Assert;
 using Directory = Lucene.Net.Store.Directory;
 using J2N.Collections.Generic.Extensions;
@@ -239,7 +239,7 @@ namespace Lucene.Net.Index
                     posUpto = freq;
                     return 0;
                 }
-                Debug.Assert(posUpto < freq);
+                Debugging.Assert(() => posUpto < freq);
 
                 if (posUpto == 0 && random.NextBoolean())
                 {
diff --git a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
index 23620f3..dca1e12 100644
--- a/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
+++ b/src/Lucene.Net.TestFramework/Index/MockRandomMergePolicy.cs
@@ -1,9 +1,9 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Index
 {
@@ -106,7 +106,7 @@ namespace Lucene.Net.Index
                 {
                     foreach (SegmentCommitInfo info in merge.Segments)
                     {
-                        Debug.Assert(segmentsToMerge.ContainsKey(info));
+                        Debugging.Assert(() => segmentsToMerge.ContainsKey(info));
                     }
                 }
             }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
index 8264666..2017704 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomCodec.cs
@@ -13,6 +13,7 @@ using Lucene.Net.Codecs.MockSep;
 using Lucene.Net.Codecs.NestedPulsing;
 using Lucene.Net.Codecs.Pulsing;
 using Lucene.Net.Codecs.SimpleText;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using System;
@@ -20,7 +21,6 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using J2N.Collections.Generic.Extensions;
 
 namespace Lucene.Net.Index
@@ -92,7 +92,7 @@ namespace Lucene.Net.Index
                 }
                 previousMappings[name] = codec;
                 // Safety:
-                Debug.Assert(previousMappings.Count < 10000, "test went insane");
+                Debugging.Assert(() => previousMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
@@ -115,7 +115,7 @@ namespace Lucene.Net.Index
                 }
                 previousDVMappings[name] = codec;
                 // Safety:
-                Debug.Assert(previousDVMappings.Count < 10000, "test went insane");
+                Debugging.Assert(() => previousDVMappings.Count < 10000, () => "test went insane");
             }
 
             //if (LuceneTestCase.VERBOSE)
diff --git a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
index b02694c..97c8f63 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomDocumentsWriterPerThreadPool.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Threading;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Index
 {
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
         public RandomDocumentsWriterPerThreadPool(int maxNumPerThreads, Random random)
             : base(maxNumPerThreads)
         {
-            Debug.Assert(MaxThreadStates >= 1);
+            Debugging.Assert(() => MaxThreadStates >= 1);
             states = new ThreadState[maxNumPerThreads];
             this.random = new Random(random.Next());
             this.maxRetry = 1 + random.Next(10);
@@ -56,14 +56,14 @@ namespace Lucene.Net.Index
                     }
                 }
             }
-            Debug.Assert(NumThreadStatesActive > 0);
+            Debugging.Assert(() => NumThreadStatesActive > 0);
             for (int i = 0; i < maxRetry; i++)
             {
                 int ord = random.Next(NumThreadStatesActive);
                 lock (this)
                 {
                     threadState = states[ord];
-                    Debug.Assert(threadState != null);
+                    Debugging.Assert(() => threadState != null);
                 }
 
                 if (threadState.TryLock())
@@ -89,12 +89,12 @@ namespace Lucene.Net.Index
                 if (newThreadState != null) // did we get a new state?
                 {
                     threadState = states[NumThreadStatesActive - 1] = newThreadState;
-                    //Debug.Assert(threadState.HeldByCurrentThread);
+                    //Debugging.Assert(threadState.HeldByCurrentThread);
                     return threadState;
                 }
                 // if no new state is available lock the random one
             }
-            Debug.Assert(threadState != null);
+            Debugging.Assert(() => threadState != null);
             threadState.@Lock();
             return threadState;
         }
diff --git a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
index 196f1b9..146e070 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -7,7 +8,6 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Index
 {
@@ -440,7 +440,7 @@ namespace Lucene.Net.Index
                         Console.WriteLine("RIW: doRandomForceMerge(" + limit + ")");
                     }
                     IndexWriter.ForceMerge(limit);
-                    Debug.Assert(!doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
+                    Debugging.Assert(() => !doRandomForceMergeAssert || IndexWriter.SegmentCount <= limit, () => "limit=" + limit + " actual=" + IndexWriter.SegmentCount);
                 }
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
index 20a69f9..e2dbc3b 100644
--- a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
@@ -1,6 +1,7 @@
 using J2N.Threading;
 using J2N.Threading.Atomic;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
@@ -16,7 +17,6 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Directory = Lucene.Net.Store.Directory;
 
 namespace Lucene.Net.Index
@@ -227,7 +227,7 @@ namespace Lucene.Net.Index
                                 if (toDeleteSubDocs.Count > 0 && Random.NextBoolean())
                                 {
                                     delSubDocs = toDeleteSubDocs[Random.Next(toDeleteSubDocs.Count)];
-                                    Debug.Assert(!delSubDocs.Deleted);
+                                    Debugging.Assert(() => !delSubDocs.Deleted);
                                     toDeleteSubDocs.Remove(delSubDocs);
                                     // Update doc block, replacing prior packID
                                     packID = delSubDocs.PackID;
@@ -364,7 +364,7 @@ namespace Lucene.Net.Index
 
                             foreach (SubDocs subDocs in toDeleteSubDocs)
                             {
-                                Debug.Assert(!subDocs.Deleted);
+                                Debugging.Assert(() => !subDocs.Deleted);
                                 delPackIDs.Add(subDocs.PackID);
                                 outerInstance.DeleteDocuments(new Term("packID", subDocs.PackID));
                                 subDocs.Deleted = true;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
index 1082d68..4d88aa5 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingBulkScorer.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Search
 {
@@ -61,7 +61,7 @@ namespace Lucene.Net.Search
                 try
                 {
                     bool remaining = @in.Score(collector, DocsEnum.NO_MORE_DOCS);
-                    Debug.Assert(!remaining);
+                    Debugging.Assert(() => !remaining);
                 }
 #pragma warning disable 168
                 catch (NotSupportedException e)
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
index 087b31e..b2e7795 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingCollector.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Search
 {
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
         {
             if (inOrder || !AcceptsDocsOutOfOrder)
             {
-                Debug.Assert(doc > lastCollected, "Out of order : " + lastCollected + " " + doc);
+                Debugging.Assert(() => doc > lastCollected, () => "Out of order : " + lastCollected + " " + doc);
             }
             @in.Collect(doc);
             lastCollected = doc;
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
index df19e58..72351d5 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingScorer.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using System.Runtime.CompilerServices;
 
 namespace Lucene.Net.Search
@@ -105,10 +105,10 @@ namespace Lucene.Net.Search
 
         public override float GetScore()
         {
-            Debug.Assert(Iterating());
+            Debugging.Assert(Iterating);
             float score = @in.GetScore();
-            Debug.Assert(!float.IsNaN(score));
-            Debug.Assert(!float.IsNaN(score));
+            Debugging.Assert(() => !float.IsNaN(score));
+            Debugging.Assert(() => !float.IsNaN(score));
             return score;
         }
 
@@ -125,7 +125,7 @@ namespace Lucene.Net.Search
         {
             get
             {
-                Debug.Assert(Iterating());
+                Debugging.Assert(Iterating);
                 return @in.Freq;
             }
         }
diff --git a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
index 0ed15a7..14db582 100644
--- a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
+++ b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
@@ -7,7 +8,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Assert = Lucene.Net.TestFramework.Assert;
 using Directory = Lucene.Net.Store.Directory;
 
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search
 
         private static IndexReader MakeEmptyIndex(Random random, int numDocs)
         {
-            Debug.Assert(numDocs > 0);
+            Debugging.Assert(() => numDocs > 0);
             Directory d = new MockDirectoryWrapper(random, new RAMDirectory());
             IndexWriter w = new IndexWriter(d, new IndexWriterConfig(LuceneTestCase.TEST_VERSION_CURRENT, new MockAnalyzer(random)));
             for (int i = 0; i < numDocs; i++)
@@ -487,7 +487,7 @@ namespace Lucene.Net.Search
                     leafPtr++;
                 }
                 lastReader[0] = (AtomicReader)context.Reader;
-                Debug.Assert(readerContextArray[leafPtr].Reader == context.Reader);
+                Debugging.Assert(() => readerContextArray[leafPtr].Reader == context.Reader);
                 this.scorer = null;
                 lastDoc[0] = -1;
             }
diff --git a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
index 25515b6..f0cf871 100644
--- a/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
+++ b/src/Lucene.Net.TestFramework/Search/RandomSimilarityProvider.cs
@@ -1,9 +1,9 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search.Similarities;
 using System;
 using System.Collections.Generic;
 using System.Text;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Search
 {
@@ -71,7 +71,7 @@ namespace Lucene.Net.Search
         {
             lock (this)
             {
-                Debug.Assert(field != null);
+                Debugging.Assert(() => field != null);
                 if (!previousMappings.TryGetValue(field, out Similarity sim) || sim == null)
                 {
                     sim = knownSims[Math.Max(0, Math.Abs(perFieldSeed ^ field.GetHashCode())) % knownSims.Count];
diff --git a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
index 945d2d6..9b770f4 100644
--- a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs
@@ -1,6 +1,7 @@
 using J2N.Collections.Generic.Extensions;
 using J2N.Threading;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Store;
@@ -11,7 +12,6 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 #if FEATURE_SERIALIZABLE_EXCEPTIONS
 using System.Runtime.Serialization;
 #endif
@@ -220,7 +220,7 @@ namespace Lucene.Net.Search
                 }
                 else
                 {
-                    Debug.Assert(searchAfter == null); // not supported yet
+                    Debugging.Assert(() => searchAfter == null); // not supported yet
                     return s.LocalSearch(q, numHits, sort);
                 }
             }
@@ -306,7 +306,7 @@ namespace Lucene.Net.Search
                     this.outerInstance = nodeState;
                     this.nodeVersions = nodeVersions;
                     MyNodeID = nodeID;
-                    Debug.Assert(MyNodeID == nodeState.MyNodeID, "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
+                    Debugging.Assert(() => MyNodeID == nodeState.MyNodeID, () => "myNodeID=" + nodeID + " NodeState.this.myNodeID=" + nodeState.MyNodeID);
                 }
 
                 public override Query Rewrite(Query original)
@@ -348,7 +348,7 @@ namespace Lucene.Net.Search
 
                 public override TermStatistics TermStatistics(Term term, TermContext context)
                 {
-                    Debug.Assert(term != null);
+                    Debugging.Assert(() => term != null);
                     long docFreq = 0;
                     long totalTermFreq = 0;
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
@@ -364,7 +364,7 @@ namespace Lucene.Net.Search
                             subStats = outerInstance.termStatsCache[key];
                             // We pre-cached during rewrite so all terms
                             // better be here...
-                            Debug.Assert(subStats != null);
+                            Debugging.Assert(() => subStats != null);
                         }
 
                         long nodeDocFreq = subStats.DocFreq;
@@ -419,7 +419,7 @@ namespace Lucene.Net.Search
                         }
                         // Collection stats are pre-shared on reopen, so,
                         // we better not have a cache miss:
-                        Debug.Assert(nodeStats != null, "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
+                        Debugging.Assert(() => nodeStats != null, () => "myNodeID=" + MyNodeID + " nodeID=" + nodeID + " version=" + nodeVersions[nodeID] + " field=" + field);
 
                         long nodeDocCount = nodeStats.DocCount;
                         if (docCount >= 0 && nodeDocCount >= 0)
@@ -451,7 +451,7 @@ namespace Lucene.Net.Search
                             sumDocFreq = -1;
                         }
 
-                        Debug.Assert(nodeStats.MaxDoc >= 0);
+                        Debugging.Assert(() => nodeStats.MaxDoc >= 0);
                         maxDoc += nodeStats.MaxDoc;
                     }
 
@@ -551,7 +551,7 @@ namespace Lucene.Net.Search
 
                 public override TopFieldDocs Search(Query query, int numHits, Sort sort)
                 {
-                    Debug.Assert(sort != null);
+                    Debugging.Assert(() => sort != null);
                     TopDocs[] shardHits = new TopDocs[nodeVersions.Length];
                     for (int nodeID = 0; nodeID < nodeVersions.Length; nodeID++)
                     {
@@ -604,7 +604,7 @@ namespace Lucene.Net.Search
 
             public void InitSearcher(long[] nodeVersions)
             {
-                Debug.Assert(currentShardSearcher == null);
+                Debugging.Assert(() => currentShardSearcher == null);
                 Array.Copy(nodeVersions, 0, currentNodeVersions, 0, currentNodeVersions.Length);
                 currentShardSearcher = new ShardIndexSearcher(this, GetCurrentNodeVersions(), Mgr.Acquire().IndexReader, MyNodeID);
             }
@@ -781,8 +781,8 @@ namespace Lucene.Net.Search
             for (int nodeID = 0; nodeID < numNodes; nodeID++)
             {
                 IndexSearcher s = m_nodes[nodeID].Mgr.Acquire();
-                Debug.Assert(nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
-                Debug.Assert(s != null);
+                Debugging.Assert(() => nodeVersions[nodeID] == m_nodes[nodeID].Searchers.Record(s));
+                Debugging.Assert(() => s != null);
                 try
                 {
                     BroadcastNodeReopen(nodeID, nodeVersions[nodeID], s);
diff --git a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
index ff08f44..16e968f 100644
--- a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
@@ -1,4 +1,6 @@
+using J2N.Runtime.CompilerServices;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Support;
@@ -10,11 +12,9 @@ using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using JCG = J2N.Collections.Generic;
 using AssertionError = Lucene.Net.Diagnostics.AssertionException;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
-using J2N.Runtime.CompilerServices;
+using JCG = J2N.Collections.Generic;
 #if FEATURE_SERIALIZABLE_EXCEPTIONS
 using System.Runtime.Serialization;
 #endif
@@ -963,7 +963,7 @@ namespace Lucene.Net.Store
                                             {
                                                 if (endSet.Contains(s) && !startSet.Contains(s))
                                                 {
-                                                    Debug.Assert(pendingDeletions.Contains(s));
+                                                    Debugging.Assert(() => pendingDeletions.Contains(s));
                                                     if (LuceneTestCase.Verbose)
                                                     {
                                                         Console.WriteLine("MDW: Unreferenced check: Ignoring referenced file: " + s + " " + 
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Store
                                         extras += "\n\nThese files we had previously tried to delete, but couldn't: " + pendingDeletions;
                                     }
 
-                                    Debug.Assert(false, "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
+                                    Debugging.Assert(() => false, () => "unreferenced files: before delete:\n    " + Arrays.ToString(startFiles) + "\n  after delete:\n    " + Arrays.ToString(endFiles) + extras);
                                 }
 
                                 DirectoryReader ir1 = DirectoryReader.Open(this);
@@ -1034,7 +1034,7 @@ namespace Lucene.Net.Store
                                 DirectoryReader ir2 = DirectoryReader.Open(this);
                                 int numDocs2 = ir2.NumDocs;
                                 ir2.Dispose();
-                                Debug.Assert(numDocs1 == numDocs2, "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
+                                Debugging.Assert(() => numDocs1 == numDocs2, () => "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2);
                             }
                         }
                     }
diff --git a/src/Lucene.Net.TestFramework/Support/Diagnostics/Debug.cs b/src/Lucene.Net.TestFramework/Support/Diagnostics/Debug.cs
deleted file mode 100644
index e8d9a9d..0000000
--- a/src/Lucene.Net.TestFramework/Support/Diagnostics/Debug.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-namespace Lucene.Net.Diagnostics
-{
-    /*
-     * Licensed to the Apache Software Foundation (ASF) under one or more
-     * contributor license agreements.  See the NOTICE file distributed with
-     * this work for additional information regarding copyright ownership.
-     * The ASF licenses this file to You under the Apache License, Version 2.0
-     * (the "License"); you may not use this file except in compliance with
-     * the License.  You may obtain a copy of the License at
-     *
-     *     http://www.apache.org/licenses/LICENSE-2.0
-     *
-     * Unless required by applicable law or agreed to in writing, software
-     * distributed under the License is distributed on an "AS IS" BASIS,
-     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     * See the License for the specific language governing permissions and
-     * limitations under the License.
-     */
-
-    /// <summary>
-    /// Provides a set of methods that help debug your code.
-    /// </summary>
-    internal static class Debug
-    {
-        /// <summary>
-        /// Checks for a condition; if the condition is <c>false</c>, throws an <see cref="AssertionException"/>.
-        /// </summary>
-        /// <param name="condition">The conditional expression to evaluate. If the condition is <c>true</c>, no exception is thrown.</param>
-        public static void Assert(bool condition)
-        {
-            if (Debugging.AssertsEnabled && !condition)
-                throw new AssertionException();
-        }
-
-        /// <summary>
-        /// Checks for a condition; if the condition is <c>false</c>, throws an <see cref="AssertionException"/> with the specified <paramref name="message"/>.
-        /// </summary>
-        /// <param name="condition">The conditional expression to evaluate. If the condition is <c>true</c>, no exception is thrown.</param>
-        /// <param name="message">The message to use </param>
-        public static void Assert(bool condition, string message)
-        {
-            if (Debugging.AssertsEnabled && !condition)
-                throw new AssertionException(message);
-        }
-    }
-}
diff --git a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
index b142907..861bb3e 100644
--- a/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Support/JavaCompatibility/LuceneTestCase.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
 using Assert = Lucene.Net.TestFramework.Assert;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Util
@@ -259,7 +259,7 @@ namespace Lucene.Net.Util
         [ExceptionToNetNumericConvention] // LUCENENET: This is for making test porting easier, keeping as-is
         internal int randomIntBetween(int min, int max)
         {
-            Debug.Assert(max >= min, "max must be >= min: " + min + ", " + max);
+            Debugging.Assert(() => max >= min, () => "max must be >= min: " + min + ", " + max);
             long range = (long)max - (long)min;
             if (range < int.MaxValue)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
index d7f617e..2f2b307 100644
--- a/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/Automaton/AutomatonTestUtil.cs
@@ -1,9 +1,9 @@
 using J2N;
 using J2N.Runtime.CompilerServices;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using JCG = J2N.Collections.Generic;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Util.Automaton
 {
@@ -191,7 +191,7 @@ namespace Lucene.Net.Util.Automaton
                 }
             }
 
-            Debug.Assert(code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), "code=" + code + " min=" + t.Min + " max=" + t.Max);
+            Debugging.Assert(() => code >= t.Min && code <= t.Max && (code < UnicodeUtil.UNI_SUR_HIGH_START || code > UnicodeUtil.UNI_SUR_LOW_END), () => "code=" + code + " min=" + t.Min + " max=" + t.Max);
             return code;
         }
 
@@ -399,7 +399,7 @@ namespace Lucene.Net.Util.Automaton
         {
             int numStates = a.GetNumberOfStates();
             a.ClearNumberedStates(); // force recomputation of cached numbered states
-            Debug.Assert(numStates == a.GetNumberOfStates(), "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
+            Debugging.Assert(() => numStates == a.GetNumberOfStates(), () => "automaton has " + (numStates - a.GetNumberOfStates()) + " detached states");
         }
     }
 
diff --git a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
index 1be2cbf..83f4ded 100644
--- a/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/BaseDocIdSetTestCase.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using System;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Assert = Lucene.Net.TestFramework.Assert;
 using BitSet = J2N.Collections.BitSet;
 
@@ -56,7 +56,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static BitSet RandomSet(int numBits, int numBitsSet)
         {
-            Debug.Assert(numBitsSet <= numBits);
+            Debugging.Assert(() => numBitsSet <= numBits);
             BitSet set = new BitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
index 4deb2eb..db6aea8 100644
--- a/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/FailOnNonBulkMergesInfoStream.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Util
 {
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util
 
         public override void Message(string component, string message)
         {
-            Debug.Assert(!message.Contains("non-bulk merges"));
+            Debugging.Assert(() => !message.Contains("non-bulk merges"));
         }
     }
 }
\ No newline at end of file
diff --git a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
index 8465d97..a7929e0 100644
--- a/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
+++ b/src/Lucene.Net.TestFramework/Util/Fst/FSTTester.cs
@@ -1,6 +1,7 @@
 using J2N;
 using J2N.Collections;
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util.Packed;
 using System;
@@ -11,7 +12,6 @@ using System.IO;
 using System.Text;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Directory = Lucene.Net.Store.Directory;
 using JCG = J2N.Collections.Generic;
 
@@ -103,7 +103,7 @@ namespace Lucene.Net.Util.Fst
             for (int i = 0; i < ir.Length; i++)
             {
                 int x = ir.Int32s[ir.Offset + i];
-                Debug.Assert(x >= 0 && x <= 255);
+                Debugging.Assert(() => x >= 0 && x <= 255);
                 br.Bytes[i] = (byte)x;
             }
             br.Length = ir.Length;
@@ -219,7 +219,7 @@ namespace Lucene.Net.Util.Fst
         // of the term prefix that matches
         private T Run(FST<T> fst, Int32sRef term, int[] prefixLength)
         {
-            Debug.Assert(prefixLength == null || prefixLength.Length == 1);
+            Debugging.Assert(() => prefixLength == null || prefixLength.Length == 1);
             FST.Arc<T> arc = fst.GetFirstArc(new FST.Arc<T>());
             T NO_OUTPUT = fst.Outputs.NoOutput;
             T output = NO_OUTPUT;
@@ -690,7 +690,7 @@ namespace Lucene.Net.Util.Fst
                             if (!termsMap.ContainsKey(term) && term.CompareTo(pairs[upto].Input) > 0)
                             {
                                 int pos = pairs.BinarySearch(new InputOutput<T>(term, default(T)));
-                                Debug.Assert(pos < 0);
+                                Debugging.Assert(() => pos < 0);
                                 upto = -(pos + 1);
 
                                 if (random.NextBoolean())
@@ -887,7 +887,7 @@ namespace Lucene.Net.Util.Fst
                     }
                     else
                     {
-                        Debug.Assert(prune2 > 0);
+                        Debugging.Assert(() => prune2 > 0);
                         if (prune2 > 1 && cmo.Count >= prune2)
                         {
                             keep = true;
diff --git a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
index 0afece7..d89f9b4 100644
--- a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -27,7 +28,6 @@ using System.Threading.Tasks;
 using System.Text.RegularExpressions;
 using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 using Assert = Lucene.Net.TestFramework.Assert;
 using Directory = Lucene.Net.Store.Directory;
 using FieldInfo = Lucene.Net.Index.FieldInfo;
@@ -2678,7 +2678,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermsStatisticsEquals(string info, Terms leftTerms, Terms rightTerms)
         {
-            Debug.Assert(leftTerms.Comparer == rightTerms.Comparer);
+            Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount, info);
@@ -3053,7 +3053,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertStoredFieldsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debug.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
+            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Document leftDoc = leftReader.Document(i);
@@ -3100,7 +3100,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public virtual void AssertTermVectorsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debug.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
+            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
                 Fields leftFields = leftReader.GetTermVectors(i);
@@ -3270,7 +3270,7 @@ namespace Lucene.Net.Util
         // TODO: this is kinda stupid, we don't delete documents in the test.
         public virtual void AssertDeletedDocsEquals(string info, IndexReader leftReader, IndexReader rightReader)
         {
-            Debug.Assert(leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
+            Debugging.Assert(() => leftReader.NumDeletedDocs == rightReader.NumDeletedDocs);
             IBits leftBits = MultiFields.GetLiveDocs(leftReader);
             IBits rightBits = MultiFields.GetLiveDocs(rightReader);
 
@@ -3281,7 +3281,7 @@ namespace Lucene.Net.Util
                 return;
             }
 
-            Debug.Assert(leftReader.MaxDoc == rightReader.MaxDoc);
+            Debugging.Assert(() => leftReader.MaxDoc == rightReader.MaxDoc);
             Assert.AreEqual(leftBits.Length, rightBits.Length, info);
             for (int i = 0; i < leftReader.MaxDoc; i++)
             {
@@ -3365,7 +3365,7 @@ namespace Lucene.Net.Util
         ////        if (TempDirBase == null)
         ////        {
         ////            DirectoryInfo directory = new DirectoryInfo(System.IO.Path.GetTempPath());
-        ////            //Debug.Assert(directory.Exists && directory.Directory != null && directory.CanWrite());
+        ////            //Debugging.Assert(() => directory.Exists && directory.Directory != null && directory.CanWrite());
 
         ////            RandomizedContext ctx = RandomizedContext.Current;
         ////            Type clazz = ctx.GetTargetType;
@@ -3504,7 +3504,7 @@ namespace Lucene.Net.Util
         /// </summary>
         private static void RegisterToRemoveAfterSuite(FileSystemInfo f)
         {
-            Debug.Assert(f != null);
+            Debugging.Assert(() => f != null);
 
             if (LuceneTestCase.LeaveTemporary)
             {
diff --git a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
index c947785..50f9d60 100644
--- a/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
+++ b/src/Lucene.Net.TestFramework/Util/NullInfoStream.cs
@@ -1,4 +1,4 @@
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Util
 {
@@ -29,13 +29,13 @@ namespace Lucene.Net.Util
     {
         public override void Message(string component, string message)
         {
-            Debug.Assert(component != null);
-            Debug.Assert(message != null);
+            Debugging.Assert(() => component != null);
+            Debugging.Assert(() => message != null);
         }
 
         public override bool IsEnabled(string component)
         {
-            Debug.Assert(component != null);
+            Debugging.Assert(() => component != null);
             return true; // to actually enable logging, we just ignore on message()
         }
 
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
index fe08c3e..f3cc295 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
@@ -56,7 +56,7 @@ namespace Lucene.Net.Util
           {
             try
             {
-              Debug.Assert(false);
+              Debugging.Assert(false);
               string msg = "Test class requires enabled assertions, enable globally (-ea)" + " or for Solr/Lucene subpackages only: " + Description.ClassName;
               Console.Error.WriteLine(msg);
               throw new Exception(msg);
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
index 515c22b..eaf6433 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
@@ -10,6 +10,7 @@ using Lucene.Net.Codecs.Lucene45;
 using Lucene.Net.Codecs.Lucene46;
 using Lucene.Net.Codecs.MockRandom;
 using Lucene.Net.Codecs.SimpleText;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Search.Similarities;
@@ -21,7 +22,6 @@ using System.Reflection;
 using System.Threading;
 using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
-using Debug = Lucene.Net.Diagnostics.Debug;
 
 // LUCENENET NOTE: These are primarily here because they are referred to
 // in the XML documentation. Be sure to add a new option if a new test framework
@@ -169,7 +169,7 @@ namespace Lucene.Net.Util
                                                                 !ShouldAvoidCodec("Lucene3x"))) // preflex-only setup
             {
                 codec = Codec.ForName("Lucene3x");
-                Debug.Assert((codec is PreFlexRWCodec), "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (codec is PreFlexRWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
             }
             else if ("Lucene40".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
@@ -179,8 +179,8 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene40");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debug.Assert((codec is Lucene40RWCodec), "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
-                Debug.Assert((PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (codec is Lucene40RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (PostingsFormat.ForName("Lucene40") is Lucene40RWPostingsFormat), () => "fix your IPostingsFormatFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene41".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -190,7 +190,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene41");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debug.Assert((codec is Lucene41RWCodec), "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (codec is Lucene41RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene42".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -200,7 +200,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene42");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debug.Assert((codec is Lucene42RWCodec), "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (codec is Lucene42RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if ("Lucene45".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) || ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) &&
                                                                     "random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) &&
@@ -210,7 +210,7 @@ namespace Lucene.Net.Util
             {
                 codec = Codec.ForName("Lucene45");
                 LuceneTestCase.OldFormatImpersonationIsActive = true;
-                Debug.Assert((codec is Lucene45RWCodec), "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
+                Debugging.Assert(() => (codec is Lucene45RWCodec), () => "fix your ICodecFactory to scan Lucene.Net.Tests before Lucene.Net.TestFramework");
             }
             else if (("random".Equals(LuceneTestCase.TestPostingsFormat, StringComparison.Ordinal) == false) 
                 || ("random".Equals(LuceneTestCase.TestDocValuesFormat, StringComparison.Ordinal) == false))
@@ -275,7 +275,7 @@ namespace Lucene.Net.Util
             }
             else
             {
-                Debug.Assert(false);
+                Debugging.Assert(() => false);
             }
             Codec.Default = codec;
 
diff --git a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
index e4bb112..1a8b2a1 100644
--- a/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
+++ b/src/Lucene.Net.TestFramework/Util/ThrottledIndexOutput.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using System;
 using System.Threading;
-using Debug = Lucene.Net.Diagnostics.Debug; // LUCENENET NOTE: We cannot use System.Diagnostics.Debug because those calls will be optimized out of the release!
 
 namespace Lucene.Net.Util
 {
@@ -61,7 +61,7 @@ namespace Lucene.Net.Util
 
         public ThrottledIndexOutput(int bytesPerSecond, long flushDelayMillis, long closeDelayMillis, long seekDelayMillis, long minBytesWritten, IndexOutput @delegate)
         {
-            Debug.Assert(bytesPerSecond > 0);
+            Debugging.Assert(() => bytesPerSecond > 0);
             this.@delegate = @delegate;
             this.bytesPerSecond = bytesPerSecond;
             this.flushDelayMillis = flushDelayMillis;


[lucenenet] 03/13: Converted all non-test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit 8de67141e02e219b78d480f36d730cb0d9acb9d4
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Thu Aug 13 16:58:23 2020 +0700

    Converted all non-test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()
---
 .../Analysis/CharFilter/BaseCharFilter.cs          |   5 +-
 .../Analysis/CharFilter/HTMLStripCharFilter.cs     |  23 +--
 .../Analysis/CharFilter/MappingCharFilter.cs       |   3 +-
 .../Analysis/CharFilter/NormalizeCharMap.cs        |   6 +-
 .../Compound/CompoundWordTokenFilterBase.cs        |   4 +-
 .../Analysis/Gl/GalicianStemmer.cs                 |   6 +-
 .../Analysis/Hunspell/Dictionary.cs                |  10 +-
 .../Analysis/Hunspell/Stemmer.cs                   |   6 +-
 .../Analysis/Miscellaneous/ASCIIFoldingFilter.cs   |   6 +-
 .../Miscellaneous/SingleTokenTokenStream.cs        |   5 +-
 .../Analysis/NGram/NGramTokenizer.cs               |   5 +-
 .../Pattern/PatternCaptureGroupTokenFilter.cs      |   3 +-
 .../Analysis/Pt/PortugueseStemmer.cs               |   4 +-
 .../Analysis/Pt/RSLPStemmerBase.cs                 |   2 +-
 .../Analysis/Synonym/SynonymFilter.cs              |  20 +--
 .../Analysis/Synonym/SynonymMap.cs                 |   7 +-
 .../Analysis/Util/CharArrayMap.cs                  |   6 +-
 .../Analysis/Util/CharTokenizer.cs                 |   8 +-
 .../Analysis/Util/CharacterUtils.cs                |  21 +--
 .../Analysis/Util/RollingCharBuffer.cs             |  23 +--
 .../Analysis/Util/SegmentingTokenizerBase.cs       |   3 +-
 .../Analysis/Util/StemmerUtil.cs                   |   7 +-
 .../Analysis/Icu/ICUNormalizer2CharFilter.cs       |   3 +-
 .../Analysis/Icu/Segmentation/ICUTokenizer.cs      |   3 +-
 .../Icu/Segmentation/ICUTokenizerFactory.cs        |   5 +-
 .../Dict/TokenInfoFST.cs                           |   5 +-
 .../GraphvizFormatter.cs                           |   4 +-
 .../JapaneseIterationMarkCharFilter.cs             |   2 +-
 .../JapaneseTokenizer.cs                           |  36 ++---
 .../Tools/BinaryDictionaryWriter.cs                |  25 +--
 .../Tools/ConnectionCostsBuilder.cs                |   7 +-
 .../Tools/ConnectionCostsWriter.cs                 |   5 +-
 .../BeiderMorseFilter.cs                           |   4 +-
 .../ByTask/Utils/AnalyzerFactory.cs                |   4 +-
 src/Lucene.Net.Benchmark/Quality/QualityStats.cs   |   3 +-
 src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs |   3 +-
 .../BlockTerms/BlockTermsReader.cs                 |  33 ++--
 .../BlockTerms/BlockTermsWriter.cs                 |  14 +-
 .../BlockTerms/FixedGapTermsIndexReader.cs         |  25 +--
 .../BlockTerms/FixedGapTermsIndexWriter.cs         |   3 +-
 .../BlockTerms/VariableGapTermsIndexReader.cs      |   4 +-
 .../BlockTerms/VariableGapTermsIndexWriter.cs      |   4 +-
 .../Bloom/BloomFilteringPostingsFormat.cs          |   3 +-
 src/Lucene.Net.Codecs/Bloom/FuzzySet.cs            |   3 +-
 .../IntBlock/FixedIntBlockIndexInput.cs            |   5 +-
 .../IntBlock/FixedIntBlockIndexOutput.cs           |   4 +-
 .../IntBlock/VariableIntBlockIndexInput.cs         |   3 +-
 .../IntBlock/VariableIntBlockIndexOutput.cs        |   9 +-
 .../Memory/DirectDocValuesConsumer.cs              |   5 +-
 .../Memory/DirectDocValuesProducer.cs              |   3 +-
 .../Memory/DirectPostingsFormat.cs                 |  57 +++----
 src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs  |  13 +-
 src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs     |   9 +-
 src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs     |  11 +-
 .../Memory/MemoryDocValuesConsumer.cs              |   5 +-
 .../Memory/MemoryDocValuesProducer.cs              |   3 +-
 .../Memory/MemoryPostingsFormat.cs                 |  27 ++--
 .../Pulsing/PulsingPostingsFormat.cs               |   3 +-
 .../Pulsing/PulsingPostingsReader.cs               |  11 +-
 .../Pulsing/PulsingPostingsWriter.cs               |  21 +--
 src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs     |  13 +-
 src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs     |  11 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs     |   5 +-
 src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs     |   5 +-
 .../SimpleText/SimpleTextDocValuesReader.cs        |  47 +++---
 .../SimpleText/SimpleTextDocValuesWriter.cs        |  41 ++---
 .../SimpleText/SimpleTextFieldInfosReader.cs       |  31 ++--
 .../SimpleText/SimpleTextFieldInfosWriter.cs       |   5 +-
 .../SimpleText/SimpleTextFieldsReader.cs           |  15 +-
 .../SimpleText/SimpleTextFieldsWriter.cs           |  11 +-
 .../SimpleText/SimpleTextLiveDocsFormat.cs         |   9 +-
 .../SimpleText/SimpleTextSegmentInfoReader.cs      |  19 +--
 .../SimpleText/SimpleTextStoredFieldsReader.cs     |  17 ++-
 .../SimpleText/SimpleTextTermVectorsReader.cs      |  37 ++---
 .../SimpleText/SimpleTextTermVectorsWriter.cs      |   7 +-
 src/Lucene.Net.Expressions/ExpressionComparator.cs |   5 +-
 src/Lucene.Net.Expressions/ScoreFunctionValues.cs  |   3 +-
 src/Lucene.Net.Facet/DrillDownQuery.cs             |   5 +-
 src/Lucene.Net.Facet/DrillSideways.cs              |   3 +-
 src/Lucene.Net.Facet/DrillSidewaysScorer.cs        |   8 +-
 src/Lucene.Net.Facet/FacetsConfig.cs               |   5 +-
 src/Lucene.Net.Facet/Range/LongRangeCounter.cs     |  13 +-
 src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs      |   5 +-
 .../Taxonomy/Directory/DirectoryTaxonomyWriter.cs  |   7 +-
 .../Taxonomy/Directory/TaxonomyIndexArrays.cs      |   5 +-
 src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs        |   3 +-
 .../Taxonomy/FloatTaxonomyFacets.cs                |   5 +-
 src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs    |   3 +-
 .../AbstractFirstPassGroupingCollector.cs          |  13 +-
 src/Lucene.Net.Grouping/BlockGroupingCollector.cs  |  11 +-
 src/Lucene.Net.Grouping/SearchGroup.cs             |  17 ++-
 .../Term/TermGroupFacetCollector.cs                |   7 +-
 .../PostingsHighlight/MultiTermHighlighting.cs     |   5 +-
 .../PostingsHighlight/Passage.cs                   |   5 +-
 .../PostingsHighlight/PostingsHighlighter.cs       |  17 ++-
 .../VectorHighlight/BaseFragListBuilder.cs         |   5 +-
 .../VectorHighlight/FieldTermStack.cs              |   5 +-
 src/Lucene.Net.Join/ToChildBlockJoinQuery.cs       |  13 +-
 src/Lucene.Net.Join/ToParentBlockJoinCollector.cs  |   7 +-
 src/Lucene.Net.Join/ToParentBlockJoinQuery.cs      |   7 +-
 .../MemoryIndex.MemoryIndexReader.cs               |  11 +-
 src/Lucene.Net.Memory/MemoryIndex.cs               |  15 +-
 src/Lucene.Net.Misc/Document/LazyDocument.cs       |   9 +-
 .../Index/MultiPassIndexSplitter.cs                |   3 +-
 src/Lucene.Net.Misc/Index/PKIndexSplitter.cs       |   5 +-
 src/Lucene.Net.Misc/Index/Sorter/Sorter.cs         |   7 +-
 .../Index/Sorter/SortingAtomicReader.cs            |   5 +-
 .../Index/Sorter/SortingMergePolicy.cs             |   4 +-
 src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs      |   7 +-
 .../Util/Fst/UpToTwoPositiveIntOutputs.cs          |  39 ++---
 src/Lucene.Net.Queries/BooleanFilter.cs            |   5 +-
 src/Lucene.Net.Queries/CommonTermsQuery.cs         |   3 +-
 .../Processors/AnalyzerQueryNodeProcessor.cs       |  11 +-
 .../Simple/SimpleQueryParser.cs                    |   5 +-
 .../IndexAndTaxonomyRevision.cs                    |   3 +-
 src/Lucene.Net.Replicator/IndexRevision.cs         |   3 +-
 src/Lucene.Net.Replicator/ReplicationClient.cs     |   5 +-
 .../Queries/SortedSetSortField.cs                  |   5 +-
 .../Prefix/AbstractPrefixTreeFilter.cs             |   3 +-
 .../Prefix/AbstractVisitingPrefixTreeFilter.cs     |  19 +--
 .../Prefix/ContainsPrefixTreeFilter.cs             |  13 +-
 src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs         |   5 +-
 .../Prefix/Tree/QuadPrefixTree.cs                  |   5 +-
 .../Prefix/Tree/SpatialPrefixTree.cs               |   5 +-
 .../Prefix/WithinPrefixTreeFilter.cs               |   5 +-
 .../Vector/DistanceValueSource.cs                  |   5 +-
 .../Suggest/Analyzing/AnalyzingSuggester.cs        |  21 +--
 .../Suggest/Analyzing/BlendedInfixSuggester.cs     |   3 +-
 .../Suggest/Analyzing/FSTUtil.cs                   |  11 +-
 .../Suggest/Analyzing/FreeTextSuggester.cs         |  15 +-
 .../Suggest/Analyzing/SuggestStopFilter.cs         |   3 +-
 .../Suggest/Fst/FSTCompletion.cs                   |   5 +-
 .../Suggest/Fst/WFSTCompletionLookup.cs            |  11 +-
 .../Suggest/UnsortedInputIterator.cs               |   9 +-
 src/Lucene.Net/Analysis/NumericTokenStream.cs      |   3 +-
 src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs  |   5 +-
 src/Lucene.Net/Codecs/BlockTermState.cs            |   4 +-
 src/Lucene.Net/Codecs/BlockTreeTermsReader.cs      | 170 ++++++++++-----------
 src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs      |  71 ++++-----
 src/Lucene.Net/Codecs/CodecUtil.cs                 |   3 +-
 .../CompressingStoredFieldsIndexWriter.cs          |   9 +-
 .../Compressing/CompressingStoredFieldsReader.cs   |  19 +--
 .../Compressing/CompressingStoredFieldsWriter.cs   |  17 ++-
 .../Compressing/CompressingTermVectorsReader.cs    |  21 +--
 .../Compressing/CompressingTermVectorsWriter.cs    |  39 ++---
 .../Codecs/Compressing/CompressionMode.cs          |   7 +-
 src/Lucene.Net/Codecs/Compressing/LZ4.cs           |  19 +--
 src/Lucene.Net/Codecs/DocValuesConsumer.cs         |   5 +-
 src/Lucene.Net/Codecs/FieldsConsumer.cs            |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs   |  41 ++---
 .../Codecs/Lucene3x/Lucene3xNormsProducer.cs       |   7 +-
 .../Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs   |   7 +-
 .../Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs  |   5 +-
 .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs   |  15 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs  |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs  |   5 +-
 .../Codecs/Lucene3x/SegmentTermPositions.cs        |   3 +-
 src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs       |   9 +-
 src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs  |  11 +-
 src/Lucene.Net/Codecs/Lucene40/BitVector.cs        |  28 ++--
 .../Codecs/Lucene40/Lucene40LiveDocsFormat.cs      |  11 +-
 .../Codecs/Lucene40/Lucene40PostingsFormat.cs      |   3 +-
 .../Codecs/Lucene40/Lucene40PostingsReader.cs      |  37 ++---
 .../Codecs/Lucene40/Lucene40StoredFieldsReader.cs  |   9 +-
 .../Codecs/Lucene40/Lucene40StoredFieldsWriter.cs  |  11 +-
 .../Codecs/Lucene40/Lucene40TermVectorsReader.cs   |  25 +--
 .../Codecs/Lucene40/Lucene40TermVectorsWriter.cs   |  19 +--
 src/Lucene.Net/Codecs/Lucene41/ForUtil.cs          |  23 +--
 .../Codecs/Lucene41/Lucene41PostingsFormat.cs      |   6 +-
 .../Codecs/Lucene41/Lucene41PostingsReader.cs      |  23 +--
 .../Codecs/Lucene41/Lucene41PostingsWriter.cs      |  13 +-
 .../Codecs/Lucene41/Lucene41SkipReader.cs          |   3 +-
 .../Codecs/Lucene42/Lucene42NormsConsumer.cs       |   5 +-
 .../Codecs/Lucene45/Lucene45DocValuesConsumer.cs   |   5 +-
 .../Codecs/Lucene46/Lucene46FieldInfosWriter.cs    |   5 +-
 src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs      |   3 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs  |   3 +-
 src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs  |   3 +-
 .../Codecs/PerField/PerFieldDocValuesFormat.cs     |  11 +-
 .../Codecs/PerField/PerFieldPostingsFormat.cs      |   9 +-
 src/Lucene.Net/Codecs/PostingsConsumer.cs          |   3 +-
 src/Lucene.Net/Codecs/TermVectorsWriter.cs         |  17 ++-
 src/Lucene.Net/Codecs/TermsConsumer.cs             |  11 +-
 src/Lucene.Net/Index/AtomicReader.cs               |   9 +-
 src/Lucene.Net/Index/AtomicReaderContext.cs        |   3 +-
 src/Lucene.Net/Index/AutomatonTermsEnum.cs         |   9 +-
 src/Lucene.Net/Index/BitsSlice.cs                  |   5 +-
 src/Lucene.Net/Index/BufferedUpdatesStream.cs      |  49 +++---
 src/Lucene.Net/Index/ByteSliceReader.cs            |  17 ++-
 src/Lucene.Net/Index/ByteSliceWriter.cs            |  13 +-
 src/Lucene.Net/Index/CheckIndex.cs                 |  31 ++--
 src/Lucene.Net/Index/CompositeReader.cs            |   5 +-
 src/Lucene.Net/Index/CompositeReaderContext.cs     |   5 +-
 src/Lucene.Net/Index/ConcurrentMergeScheduler.cs   |   2 +-
 src/Lucene.Net/Index/DirectoryReader.cs            |   7 +-
 src/Lucene.Net/Index/DocFieldProcessor.cs          |   9 +-
 src/Lucene.Net/Index/DocTermOrds.cs                |  21 +--
 src/Lucene.Net/Index/DocValuesFieldUpdates.cs      |   5 +-
 src/Lucene.Net/Index/DocValuesProcessor.cs         |   5 +-
 src/Lucene.Net/Index/DocumentsWriter.cs            |  39 ++---
 src/Lucene.Net/Index/DocumentsWriterDeleteQueue.cs |   7 +-
 .../Index/DocumentsWriterFlushControl.cs           |  73 ++++-----
 src/Lucene.Net/Index/DocumentsWriterFlushQueue.cs  |  35 ++---
 src/Lucene.Net/Index/DocumentsWriterPerThread.cs   |  33 ++--
 .../Index/DocumentsWriterPerThreadPool.cs          |  25 +--
 .../Index/DocumentsWriterStallControl.cs           |   9 +-
 src/Lucene.Net/Index/FieldInfo.cs                  |  29 ++--
 src/Lucene.Net/Index/FieldInfos.cs                 |  11 +-
 src/Lucene.Net/Index/FilteredTermsEnum.cs          |   7 +-
 src/Lucene.Net/Index/FlushPolicy.cs                |   9 +-
 src/Lucene.Net/Index/FreqProxTermsWriter.cs        |   4 +-
 .../Index/FreqProxTermsWriterPerField.cs           |  51 +++----
 src/Lucene.Net/Index/FrozenBufferedUpdates.cs      |   8 +-
 src/Lucene.Net/Index/IndexFileDeleter.cs           |  45 +++---
 src/Lucene.Net/Index/IndexFileNames.cs             |   6 +-
 src/Lucene.Net/Index/IndexFormatTooNewException.cs |   4 +-
 src/Lucene.Net/Index/IndexFormatTooOldException.cs |   6 +-
 src/Lucene.Net/Index/IndexWriter.cs                | 145 +++++++++---------
 src/Lucene.Net/Index/LogMergePolicy.cs             |  10 +-
 src/Lucene.Net/Index/MergePolicy.cs                |  10 +-
 src/Lucene.Net/Index/MergeState.cs                 |   8 +-
 src/Lucene.Net/Index/MultiBits.cs                  |  14 +-
 src/Lucene.Net/Index/MultiDocValues.cs             |  14 +-
 src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs  |   6 +-
 src/Lucene.Net/Index/MultiDocsEnum.cs              |   4 +-
 src/Lucene.Net/Index/MultiFields.cs                |  14 +-
 src/Lucene.Net/Index/MultiTerms.cs                 |   4 +-
 src/Lucene.Net/Index/MultiTermsEnum.cs             |  24 +--
 src/Lucene.Net/Index/NormsConsumer.cs              |   8 +-
 .../Index/NumericDocValuesFieldUpdates.cs          |   4 +-
 src/Lucene.Net/Index/OrdTermState.cs               |   4 +-
 src/Lucene.Net/Index/ParallelCompositeReader.cs    |   4 +-
 src/Lucene.Net/Index/PrefixCodedTerms.cs           |   4 +-
 src/Lucene.Net/Index/ReadersAndUpdates.cs          |  50 +++---
 src/Lucene.Net/Index/SegmentCoreReaders.cs         |   8 +-
 src/Lucene.Net/Index/SegmentDocValues.cs           |   6 +-
 src/Lucene.Net/Index/SegmentInfo.cs                |   6 +-
 src/Lucene.Net/Index/SegmentInfos.cs               |  14 +-
 src/Lucene.Net/Index/SegmentMerger.cs              |   8 +-
 src/Lucene.Net/Index/SegmentReader.cs              |  14 +-
 src/Lucene.Net/Index/SimpleMergedSegmentWarmer.cs  |   4 +-
 .../Index/SingletonSortedSetDocValues.cs           |   4 +-
 src/Lucene.Net/Index/SlowCompositeReaderWrapper.cs |   6 +-
 src/Lucene.Net/Index/SnapshotDeletionPolicy.cs     |   4 +-
 src/Lucene.Net/Index/SortedDocValuesTermsEnum.cs   |   8 +-
 src/Lucene.Net/Index/SortedDocValuesWriter.cs      |   4 +-
 .../Index/SortedSetDocValuesTermsEnum.cs           |   8 +-
 src/Lucene.Net/Index/SortedSetDocValuesWriter.cs   |   6 +-
 src/Lucene.Net/Index/StandardDirectoryReader.cs    |   8 +-
 src/Lucene.Net/Index/TermContext.cs                |  14 +-
 src/Lucene.Net/Index/TermVectorsConsumer.cs        |  13 +-
 .../Index/TermVectorsConsumerPerField.cs           |  13 +-
 src/Lucene.Net/Index/TermsHashPerField.cs          |   8 +-
 .../ThreadAffinityDocumentsWriterThreadPool.cs     |   7 +-
 src/Lucene.Net/Lucene.Net.csproj                   |   1 +
 src/Lucene.Net/Search/CachingWrapperFilter.cs      |   4 +-
 src/Lucene.Net/Search/CollectionStatistics.cs      |  10 +-
 src/Lucene.Net/Search/ConstantScoreAutoRewrite.cs  |   8 +-
 src/Lucene.Net/Search/ConstantScoreQuery.cs        |  14 +-
 src/Lucene.Net/Search/DisjunctionScorer.cs         |   6 +-
 src/Lucene.Net/Search/DocIdSetIterator.cs          |  10 +-
 src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs    |   6 +-
 src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs  |   6 +-
 src/Lucene.Net/Search/ExactPhraseScorer.cs         |   4 +-
 src/Lucene.Net/Search/FieldCacheImpl.cs            |  14 +-
 src/Lucene.Net/Search/FieldCacheRangeFilter.cs     |   6 +-
 src/Lucene.Net/Search/FieldCacheRewriteMethod.cs   |   6 +-
 src/Lucene.Net/Search/FieldComparator.cs           |  14 +-
 src/Lucene.Net/Search/FieldValueHitQueue.cs        |  10 +-
 src/Lucene.Net/Search/FilteredQuery.cs             |  10 +-
 src/Lucene.Net/Search/FuzzyTermsEnum.cs            |   6 +-
 src/Lucene.Net/Search/IndexSearcher.cs             |   8 +-
 src/Lucene.Net/Search/MinShouldMatchSumScorer.cs   |   6 +-
 src/Lucene.Net/Search/MultiPhraseQuery.cs          |  12 +-
 .../Search/MultiTermQueryWrapperFilter.cs          |   6 +-
 src/Lucene.Net/Search/NumericRangeQuery.cs         |  16 +-
 src/Lucene.Net/Search/PhraseQuery.cs               |   8 +-
 src/Lucene.Net/Search/QueryRescorer.cs             |   4 +-
 src/Lucene.Net/Search/ReferenceManager.cs          |   8 +-
 src/Lucene.Net/Search/ReqOptSumScorer.cs           |   6 +-
 src/Lucene.Net/Search/ScoringRewrite.cs            |  12 +-
 src/Lucene.Net/Search/SearcherManager.cs           |   6 +-
 .../Search/Similarities/SimilarityBase.cs          |   4 +-
 src/Lucene.Net/Search/SloppyPhraseScorer.cs        |   6 +-
 src/Lucene.Net/Search/SortField.cs                 |   4 +-
 src/Lucene.Net/Search/SortRescorer.cs              |   4 +-
 src/Lucene.Net/Search/Spans/NearSpansOrdered.cs    |   8 +-
 src/Lucene.Net/Search/Spans/SpanFirstQuery.cs      |   4 +-
 .../Search/Spans/SpanPositionRangeQuery.cs         |   4 +-
 src/Lucene.Net/Search/Spans/TermSpans.cs           |   4 +-
 src/Lucene.Net/Search/TermCollectingRewrite.cs     |   4 +-
 src/Lucene.Net/Search/TermQuery.cs                 |  14 +-
 src/Lucene.Net/Search/TermScorer.cs                |   4 +-
 src/Lucene.Net/Search/TermStatistics.cs            |   6 +-
 src/Lucene.Net/Search/TopDocs.cs                   |  12 +-
 src/Lucene.Net/Search/TopScoreDocCollector.cs      |  14 +-
 src/Lucene.Net/Search/TopTermsRewrite.cs           |  20 +--
 src/Lucene.Net/Store/BaseDirectory.cs              |   5 +-
 src/Lucene.Net/Store/BufferedIndexInput.cs         |   4 +-
 src/Lucene.Net/Store/ByteArrayDataOutput.cs        |   7 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs       |  10 +-
 src/Lucene.Net/Store/CompoundFileDirectory.cs      |  10 +-
 src/Lucene.Net/Store/CompoundFileWriter.cs         |  20 +--
 src/Lucene.Net/Store/DataInput.cs                  |   4 +-
 src/Lucene.Net/Store/DataOutput.cs                 |   6 +-
 src/Lucene.Net/Store/IOContext.cs                  |   8 +-
 src/Lucene.Net/Store/IndexInput.cs                 |   2 +-
 src/Lucene.Net/Store/IndexOutput.cs                |   2 +-
 src/Lucene.Net/Store/MMapDirectory.cs              |   5 +-
 src/Lucene.Net/Store/NIOFSDirectory.cs             |   6 +-
 src/Lucene.Net/Store/RAMOutputStream.cs            |   4 +-
 .../Store/RateLimitedDirectoryWrapper.cs           |   2 +-
 src/Lucene.Net/Store/SimpleFSDirectory.cs          |   4 +-
 src/Lucene.Net/Support/BitArrayExtensions.cs       |   2 +-
 src/Lucene.Net/Support/Collections.cs              |   4 +-
 src/Lucene.Net/Util/ArrayUtil.cs                   |  43 +++---
 src/Lucene.Net/Util/AttributeSource.cs             |   5 +-
 src/Lucene.Net/Util/Automaton/Automaton.cs         |   6 +-
 src/Lucene.Net/Util/Automaton/BasicOperations.cs   |  10 +-
 src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs |  10 +-
 .../Util/Automaton/DaciukMihovAutomatonBuilder.cs  |  20 +--
 .../Util/Automaton/Lev1ParametricDescription.cs    |   6 +-
 .../Util/Automaton/Lev1TParametricDescription.cs   |   6 +-
 .../Util/Automaton/Lev2ParametricDescription.cs    |   6 +-
 .../Util/Automaton/Lev2TParametricDescription.cs   |   6 +-
 .../Util/Automaton/LevenshteinAutomata.cs          |   4 +-
 src/Lucene.Net/Util/Automaton/SortedIntSet.cs      |   4 +-
 src/Lucene.Net/Util/Automaton/State.cs             |   4 +-
 src/Lucene.Net/Util/Automaton/Transition.cs        |   9 +-
 src/Lucene.Net/Util/Automaton/UTF32ToUTF8.cs       |   6 +-
 src/Lucene.Net/Util/BroadWord.cs                   |   6 +-
 src/Lucene.Net/Util/ByteBlockPool.cs               |   4 +-
 src/Lucene.Net/Util/BytesRef.cs                    |  14 +-
 src/Lucene.Net/Util/BytesRefArray.cs               |   4 +-
 src/Lucene.Net/Util/BytesRefHash.cs                |  40 ++---
 src/Lucene.Net/Util/CharsRef.cs                    |   6 +-
 src/Lucene.Net/Util/FilterIterator.cs              |   4 +-
 src/Lucene.Net/Util/FixedBitSet.cs                 |  32 ++--
 src/Lucene.Net/Util/Fst/Builder.cs                 |  46 +++---
 src/Lucene.Net/Util/Fst/ByteSequenceOutputs.cs     |  24 +--
 src/Lucene.Net/Util/Fst/BytesRefFSTEnum.cs         |   4 +-
 src/Lucene.Net/Util/Fst/BytesStore.cs              |  20 +--
 src/Lucene.Net/Util/Fst/CharSequenceOutputs.cs     |  24 +--
 src/Lucene.Net/Util/Fst/FST.cs                     |  80 +++++-----
 src/Lucene.Net/Util/Fst/FSTEnum.cs                 |  22 +--
 src/Lucene.Net/Util/Fst/IntSequenceOutputs.cs      |  24 +--
 src/Lucene.Net/Util/Fst/IntsRefFSTEnum.cs          |   4 +-
 src/Lucene.Net/Util/Fst/NoOutputs.cs               |  18 +--
 src/Lucene.Net/Util/Fst/NodeHash.cs                |   5 +-
 src/Lucene.Net/Util/Fst/PairOutputs.cs             |  20 +--
 src/Lucene.Net/Util/Fst/PositiveIntOutputs.cs      |  26 ++--
 src/Lucene.Net/Util/Fst/Util.cs                    |  14 +-
 src/Lucene.Net/Util/IndexableBinaryStringTools.cs  |   6 +-
 src/Lucene.Net/Util/InfoStream.cs                  |   4 +-
 src/Lucene.Net/Util/IntBlockPool.cs                |  16 +-
 src/Lucene.Net/Util/IntsRef.cs                     |   6 +-
 src/Lucene.Net/Util/LongBitSet.cs                  |  32 ++--
 src/Lucene.Net/Util/LongsRef.cs                    |   6 +-
 src/Lucene.Net/Util/MergedIterator.cs              |   4 +-
 src/Lucene.Net/Util/OfflineSorter.cs               |  13 +-
 src/Lucene.Net/Util/OpenBitSet.cs                  |  36 ++---
 src/Lucene.Net/Util/PForDeltaDocIdSet.cs           |  30 ++--
 .../Util/Packed/AbstractAppendingLongBuffer.cs     |  12 +-
 .../Util/Packed/AbstractBlockPackedWriter.cs       |   4 +-
 src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs |   8 +-
 src/Lucene.Net/Util/Packed/BlockPackedReader.cs    |   4 +-
 .../Util/Packed/BlockPackedReaderIterator.cs       |  14 +-
 src/Lucene.Net/Util/Packed/BlockPackedWriter.cs    |   4 +-
 src/Lucene.Net/Util/Packed/BulkOperation.cs        |   6 +-
 src/Lucene.Net/Util/Packed/BulkOperationPacked.cs  |  18 +--
 src/Lucene.Net/Util/Packed/Direct16.cs             |  16 +-
 src/Lucene.Net/Util/Packed/Direct32.cs             |  16 +-
 src/Lucene.Net/Util/Packed/Direct64.cs             |  14 +-
 src/Lucene.Net/Util/Packed/Direct8.cs              |  16 +-
 src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs     |  30 ++--
 src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs     |   6 +-
 src/Lucene.Net/Util/Packed/GrowableWriter.cs       |   4 +-
 .../Util/Packed/MonotonicAppendingLongBuffer.cs    |   4 +-
 .../Util/Packed/MonotonicBlockPackedReader.cs      |   4 +-
 .../Util/Packed/MonotonicBlockPackedWriter.cs      |   6 +-
 src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs  |  14 +-
 src/Lucene.Net/Util/Packed/Packed64.cs             |  46 +++---
 src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs  |  42 ++---
 src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs   |  14 +-
 src/Lucene.Net/Util/Packed/PackedDataInput.cs      |   4 +-
 src/Lucene.Net/Util/Packed/PackedDataOutput.cs     |   4 +-
 src/Lucene.Net/Util/Packed/PackedInts.cs           |  64 ++++----
 src/Lucene.Net/Util/Packed/PackedReaderIterator.cs |  10 +-
 src/Lucene.Net/Util/Packed/PackedWriter.cs         |   8 +-
 src/Lucene.Net/Util/Packed/PagedMutable.cs         |   4 +-
 src/Lucene.Net/Util/PagedBytes.cs                  |  16 +-
 src/Lucene.Net/Util/QueryBuilder.cs                |  14 +-
 src/Lucene.Net/Util/RamUsageEstimator.cs           |  16 +-
 src/Lucene.Net/Util/RecyclingByteBlockAllocator.cs |   8 +-
 src/Lucene.Net/Util/RecyclingIntBlockAllocator.cs  |   8 +-
 src/Lucene.Net/Util/RollingBuffer.cs               |   8 +-
 src/Lucene.Net/Util/SentinelIntSet.cs              |   6 +-
 src/Lucene.Net/Util/Sorter.cs                      |   4 +-
 src/Lucene.Net/Util/TimSorter.cs                   |  22 +--
 src/Lucene.Net/Util/UnicodeUtil.cs                 |   6 +-
 src/Lucene.Net/Util/WAH8DocIdSet.cs                |  56 +++----
 401 files changed, 2540 insertions(+), 2384 deletions(-)

diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
index 755d4be..420822b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/BaseCharFilter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using Lucene.Net.Util;
 using System.Diagnostics;
 using System.IO;
@@ -113,7 +114,7 @@ namespace Lucene.Net.Analysis.CharFilters
             }
 
             int offset = offsets[(size == 0) ? 0 : size - 1];
-            Debug.Assert(size == 0 || off >= offset, "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
+            Debugging.Assert(() => size == 0 || off >= offset, () => "Offset #" + size + "(" + off + ") is less than the last recorded offset " + offset + "\n" + Arrays.ToString(offsets) + "\n" + Arrays.ToString(diffs));
 
             if (size == 0 || off != offsets[size - 1])
             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
index d30bad7..eb28c1f 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/HTMLStripCharFilter.cs
@@ -1,5 +1,6 @@
 using J2N;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -30952,7 +30953,7 @@ namespace Lucene.Net.Analysis.CharFilters
             /// </summary>
             internal int NextChar()
             {
-                Debug.Assert(!IsRead, "Attempting to read past the end of a segment.");
+                Debugging.Assert(() => !IsRead, () => "Attempting to read past the end of a segment.");
                 return m_buf[pos++];
             }
 
@@ -31377,7 +31378,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    Debug.Assert(false, "Exception parsing code point '" + decimalCharRef + "'");
+                                    Debugging.Assert(() => false, () => "Exception parsing code point '" + decimalCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31637,7 +31638,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 {
-                                    Debug.Assert(false, "Exception parsing hex code point '" + hexCharRef + "'");
+                                    Debugging.Assert(() => false, () => "Exception parsing hex code point '" + hexCharRef + "'");
                                 }
                                 if (codePoint <= 0x10FFFF)
                                 {
@@ -31900,7 +31901,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing high surrogate '"
+                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31909,7 +31910,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
+                                Debugging.Assert(() => false, () => "Exception parsing low surrogate '" + surrogatePair.Substring(10, 14 - 10) + "'");
                             }
                             // add (previously matched input length) + (this match length) - (substitution length)
                             cumulativeDiff += inputSegment.Length + YyLength - 2;
@@ -31931,7 +31932,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing high surrogate '"
+                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(2, 6 - 2) + "'");
                             }
                             try
@@ -31940,7 +31941,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing low surrogate '"
+                                Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                             + surrogatePair.Substring(9, 14 - 9) + "'");
                             }
                             if (char.IsLowSurrogate(lowSurrogate))
@@ -31972,7 +31973,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing high surrogate '"
+                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -31985,7 +31986,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    Debug.Assert(false, "Exception parsing low surrogate '"
+                                    Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(10, 14 - 10) + "'");
                                 }
                                 // add (previously matched input length) + (this match length) - (substitution length)
@@ -32012,7 +32013,7 @@ namespace Lucene.Net.Analysis.CharFilters
                             }
                             catch (Exception /*e*/)
                             { // should never happen
-                                Debug.Assert(false, "Exception parsing high surrogate '"
+                                Debugging.Assert(() => false, () => "Exception parsing high surrogate '"
                                             + surrogatePair.Substring(1, 6 - 1) + "'");
                             }
                             if (char.IsHighSurrogate(highSurrogate))
@@ -32024,7 +32025,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 }
                                 catch (Exception /*e*/)
                                 { // should never happen
-                                    Debug.Assert(false, "Exception parsing low surrogate '"
+                                    Debugging.Assert(() => false, () => "Exception parsing low surrogate '"
                                                 + surrogatePair.Substring(9, 14 - 9) + "'");
                                 }
                                 if (char.IsLowSurrogate(lowSurrogate))
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
index 6f3c83b..42d03df 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/MappingCharFilter.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
@@ -135,7 +136,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         if (!FST.TargetHasArcs(arc))
                         {
                             // Fast pass for single character match:
-                            Debug.Assert(arc.IsFinal);
+                            Debugging.Assert(() => arc.IsFinal);
                             lastMatchLen = 1;
                             lastMatch = arc.Output;
                         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
index 43347c9..3858445 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/CharFilter/NormalizeCharMap.cs
@@ -1,8 +1,8 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using JCG = J2N.Collections.Generic;
 
@@ -54,7 +54,7 @@ namespace Lucene.Net.Analysis.CharFilters
                         map.ReadFirstRealTargetArc(scratchArc.Target, scratchArc, fstReader);
                         while (true)
                         {
-                            Debug.Assert(scratchArc.Label != FST.END_LABEL);
+                            Debugging.Assert(() => scratchArc.Label != FST.END_LABEL);
                             cachedRootArcs[Convert.ToChar((char)scratchArc.Label)] = (new FST.Arc<CharsRef>()).CopyFrom(scratchArc);
                             if (scratchArc.IsLast)
                             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
index c6a2f3b..518651b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
@@ -1,10 +1,10 @@
 using J2N.Text;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 
 namespace Lucene.Net.Analysis.Compound
 {
@@ -110,7 +110,7 @@ namespace Lucene.Net.Analysis.Compound
         {
             if (m_tokens.Count > 0)
             {
-                Debug.Assert(current != null);
+                Debugging.Assert(() => current != null);
                 CompoundToken token = m_tokens.Dequeue();
                 RestoreState(current); // keep all other attributes untouched
                 m_termAtt.SetEmpty().Append(token.Text);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
index f2f5eeb..7aa674e 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Gl/GalicianStemmer.cs
@@ -1,6 +1,6 @@
-using System.Diagnostics;
+using Lucene.Net.Analysis.Pt;
+using Lucene.Net.Diagnostics;
 using System.Collections.Generic;
-using Lucene.Net.Analysis.Pt;
 
 namespace Lucene.Net.Analysis.Gl
 {
@@ -47,7 +47,7 @@ namespace Lucene.Net.Analysis.Gl
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            Debug.Assert(s.Length >= len + 1, "this stemmer requires an oversized array of at least 1");
+            Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = unification.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
index 70bc9c5..f770e91 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs
@@ -1,15 +1,15 @@
-using J2N.Collections.Generic.Extensions;
+using J2N;
+using J2N.Collections.Generic.Extensions;
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Support.IO;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Automaton;
 using Lucene.Net.Util.Fst;
-using J2N;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
@@ -375,7 +375,7 @@ namespace Lucene.Net.Analysis.Hunspell
                 strip.CopyTo(0, stripData, currentOffset, strip.Length - 0);
                 currentOffset += strip.Length;
             }
-            Debug.Assert(currentIndex == seenStrips.Count);
+            Debugging.Assert(() => currentIndex == seenStrips.Count);
             stripOffsets[currentIndex] = currentOffset;
         }
 
@@ -424,7 +424,7 @@ namespace Lucene.Net.Analysis.Hunspell
 
             for (int i = 0; i < numLines; i++)
             {
-                Debug.Assert(affixWriter.Position == currentAffix << 3);
+                Debugging.Assert(() => affixWriter.Position == currentAffix << 3);
                 string line = reader.ReadLine();
                 string[] ruleArgs = whitespacePattern.Split(line).TrimEnd();
 
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
index 975eb95..0b40b56 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Stemmer.cs
@@ -1,10 +1,10 @@
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Automaton;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 
@@ -210,7 +210,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            Debug.Assert(prevFlag >= 0);
+                            Debugging.Assert(() => prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, false);
                         }
                         else
@@ -279,7 +279,7 @@ namespace Lucene.Net.Analysis.Hunspell
                             // cross check incoming continuation class (flag of previous affix) against list.
                             dictionary.flagLookup.Get(append, scratch);
                             char[] appendFlags = Dictionary.DecodeFlags(scratch);
-                            Debug.Assert(prevFlag >= 0);
+                            Debugging.Assert(() => prevFlag >= 0);
                             compatible = HasCrossCheckedFlag((char)prevFlag, appendFlags, previousWasPrefix);
                         }
                         else
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
index ad8e650..d47ed47 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
@@ -1,5 +1,5 @@
-using System.Diagnostics;
-using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 
 namespace Lucene.Net.Analysis.Miscellaneous
@@ -92,7 +92,7 @@ namespace Lucene.Net.Analysis.Miscellaneous
         {
             if (state != null)
             {
-                Debug.Assert(preserveOriginal, "state should only be captured if preserveOriginal is true");
+                Debugging.Assert(() => preserveOriginal, () => "state should only be captured if preserveOriginal is true");
                 RestoreState(state);
                 posIncAttr.PositionIncrement = 0;
                 state = null;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
index 92748b4..4855e8d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/SingleTokenTokenStream.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 
 namespace Lucene.Net.Analysis.Miscellaneous
@@ -34,11 +35,11 @@ namespace Lucene.Net.Analysis.Miscellaneous
         public SingleTokenTokenStream(Token token) 
             : base(Token.TOKEN_ATTRIBUTE_FACTORY)
         {
-            Debug.Assert(token != null);
+            Debugging.Assert(() => token != null);
             this.singleToken = (Token)token.Clone();
 
             tokenAtt = AddAttribute<ICharTermAttribute>();
-            Debug.Assert(tokenAtt is Token);
+            Debugging.Assert(() => tokenAtt is Token);
         }
 
         public override sealed bool IncrementToken()
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
index 7f79f5d..1327200 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenizer.cs
@@ -1,6 +1,7 @@
 using J2N;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Diagnostics;
@@ -231,7 +232,7 @@ namespace Lucene.Net.Analysis.NGram
                 {
                     if (bufferStart + 1 + minGram > bufferEnd)
                     {
-                        Debug.Assert(exhausted);
+                        Debugging.Assert(() => exhausted);
                         return false;
                     }
                     Consume();
@@ -294,7 +295,7 @@ namespace Lucene.Net.Analysis.NGram
         public override sealed void End()
         {
             base.End();
-            Debug.Assert(bufferStart <= bufferEnd);
+            Debugging.Assert(() => bufferStart <= bufferEnd);
             int endOffset = offset;
             for (int i = bufferStart; i < bufferEnd; ++i)
             {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
index bd12158..8ca48d4 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System.Diagnostics;
 using System.Text.RegularExpressions;
@@ -154,7 +155,7 @@ namespace Lucene.Net.Analysis.Pattern
         {
             if (currentMatcher != -1 && NextCapture())
             {
-                Debug.Assert(state != null);
+                Debugging.Assert(() => state != null);
                 ClearAttributes();
                 RestoreState(state);
                 int start = matchers[currentMatcher].Groups[currentGroup[currentMatcher]].Index;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
index 70b6ae0..cdd1ece 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 using System.Collections.Generic;
 
 namespace Lucene.Net.Analysis.Pt
@@ -46,7 +46,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <returns> new valid length, stemmed </returns>
         public virtual int Stem(char[] s, int len)
         {
-            Debug.Assert(s.Length >= len + 1, "this stemmer requires an oversized array of at least 1");
+            Debugging.Assert(() => s.Length >= len + 1, () => "this stemmer requires an oversized array of at least 1");
 
             len = plural.Apply(s, len);
             len = adverb.Apply(s, len);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
index e47e0c1..942e6d5 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
@@ -304,7 +304,7 @@ namespace Lucene.Net.Analysis.Pt
             {
                 throw new Exception("Illegal Step header specified at line " /*+ r.LineNumber*/); // TODO Line number
             }
-            //Debug.Assert(headerPattern.GetGroupNumbers().Length == 4);
+            //Debugging.Assert(headerPattern.GetGroupNumbers().Length == 4);
             string name = matcher.Groups[1].Value;
             int min = int.Parse(matcher.Groups[2].Value, CultureInfo.InvariantCulture);
             int type = int.Parse(matcher.Groups[3].Value, CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
index 6b039ee..52adde9 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymFilter.cs
@@ -1,10 +1,10 @@
 using J2N;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
-using System.Diagnostics;
 using System.Globalization;
 
 namespace Lucene.Net.Analysis.Synonym
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis.Synonym
 
             public virtual CharsRef PullNext()
             {
-                Debug.Assert(upto < count);
+                Debugging.Assert(() => upto < count);
                 lastEndOffset = endOffsets[upto];
                 lastPosLength = posLengths[upto];
                 CharsRef result = outputs[upto++];
@@ -306,7 +306,7 @@ namespace Lucene.Net.Analysis.Synonym
             nextWrite = RollIncr(nextWrite);
 
             // Buffer head should never catch up to tail:
-            Debug.Assert(nextWrite != nextRead);
+            Debugging.Assert(() => nextWrite != nextRead);
         }
 
         /*
@@ -325,7 +325,7 @@ namespace Lucene.Net.Analysis.Synonym
         {
             //System.out.println("\nS: parse");
 
-            Debug.Assert(inputSkipCount == 0);
+            Debugging.Assert(() => inputSkipCount == 0);
 
             int curNextRead = nextRead;
 
@@ -337,7 +337,7 @@ namespace Lucene.Net.Analysis.Synonym
             BytesRef pendingOutput = fst.Outputs.NoOutput;
             fst.GetFirstArc(scratchArc);
 
-            Debug.Assert(scratchArc.Output == fst.Outputs.NoOutput);
+            Debugging.Assert(() => scratchArc.Output == fst.Outputs.NoOutput);
 
             int tokenCount = 0;
 
@@ -364,7 +364,7 @@ namespace Lucene.Net.Analysis.Synonym
                     else
                     {
                         //System.out.println("  input.incrToken");
-                        Debug.Assert(futureInputs[nextWrite].consumed);
+                        Debugging.Assert(() => futureInputs[nextWrite].consumed);
                         // Not correct: a syn match whose output is longer
                         // than its input can set future inputs keepOrig
                         // to true:
@@ -480,7 +480,7 @@ namespace Lucene.Net.Analysis.Synonym
             }
             else
             {
-                Debug.Assert(finished);
+                Debugging.Assert(() => finished);
             }
 
             //System.out.println("  parse done inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead + " nextWrite=" + nextWrite);
@@ -510,7 +510,7 @@ namespace Lucene.Net.Analysis.Synonym
                         int outputLen = chIDX - lastStart;
                         // Caller is not allowed to have empty string in
                         // the output:
-                        Debug.Assert(outputLen > 0, "output contains empty string: " + scratchChars);
+                        Debugging.Assert(() => outputLen > 0, () => "output contains empty string: " + scratchChars);
                         int endOffset;
                         int posLen;
                         if (chIDX == chEnd && lastStart == scratchChars.Offset)
@@ -536,7 +536,7 @@ namespace Lucene.Net.Analysis.Synonym
                         lastStart = 1 + chIDX;
                         //System.out.println("  slot=" + outputUpto + " keepOrig=" + keepOrig);
                         outputUpto = RollIncr(outputUpto);
-                        Debug.Assert(futureOutputs[outputUpto].posIncr == 1, "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
+                        Debugging.Assert(() => futureOutputs[outputUpto].posIncr == 1, () => "outputUpto=" + outputUpto + " vs nextWrite=" + nextWrite);
                     }
                 }
             }
@@ -602,7 +602,7 @@ namespace Lucene.Net.Analysis.Synonym
                         {
                             // Pass-through case: return token we just pulled
                             // but didn't capture:
-                            Debug.Assert(inputSkipCount == 1, "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
+                            Debugging.Assert(() => inputSkipCount == 1, () => "inputSkipCount=" + inputSkipCount + " nextRead=" + nextRead);
                         }
                         input.Reset();
                         if (outputs.count > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
index 1a1b68a..99c743a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Synonym/SynonymMap.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
@@ -172,8 +173,8 @@ namespace Lucene.Net.Analysis.Synonym
                     throw new ArgumentException("output.length must be > 0 (got " + output.Length + ")");
                 }
 
-                Debug.Assert(!HasHoles(input), "input has holes: " + input);
-                Debug.Assert(!HasHoles(output), "output has holes: " + output);
+                Debugging.Assert(() => !HasHoles(input), () => "input has holes: " + input);
+                Debugging.Assert(() => !HasHoles(output), () => "output has holes: " + output);
 
                 //System.out.println("fmap.add input=" + input + " numInputWords=" + numInputWords + " output=" + output + " numOutputWords=" + numOutputWords);
                 UnicodeUtil.UTF16toUTF8(output.Chars, output.Offset, output.Length, utf8Scratch);
@@ -280,7 +281,7 @@ namespace Lucene.Net.Analysis.Synonym
 
                     scratch.Grow(estimatedSize);
                     scratchOutput.Reset(scratch.Bytes, scratch.Offset, scratch.Bytes.Length);
-                    Debug.Assert(scratch.Offset == 0);
+                    Debugging.Assert(() => scratch.Offset == 0);
 
                     // now write our output data:
                     int count = 0;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
index 7438ab9..434d2c4 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayMap.cs
@@ -1,12 +1,12 @@
 using J2N;
-using J2N.Text;
 using J2N.Globalization;
+using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Diagnostics;
 using System.Globalization;
 using System.Text;
 
@@ -632,7 +632,7 @@ namespace Lucene.Net.Analysis.Util
 
         private void Rehash()
         {
-            Debug.Assert(keys.Length == values.Length);
+            Debugging.Assert(() => keys.Length == values.Length);
             int newSize = 2 * keys.Length;
             char[][] oldkeys = keys;
             MapValue[] oldvalues = values;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
index cfb9ec6..9669dd5 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharTokenizer.cs
@@ -1,8 +1,8 @@
 using J2N;
-using System.Diagnostics;
-using System.IO;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
+using System.IO;
 
 namespace Lucene.Net.Analysis.Util
 {
@@ -169,7 +169,7 @@ namespace Lucene.Net.Analysis.Util
                 {
                     if (length == 0) // start of token
                     {
-                        Debug.Assert(start == -1);
+                        Debugging.Assert(() => start == -1);
                         start = offset + bufferIndex - charCount;
                         end = start;
                     } // check if a supplementary could run out of bounds
@@ -191,7 +191,7 @@ namespace Lucene.Net.Analysis.Util
             }
 
             termAtt.Length = length;
-            Debug.Assert(start != -1);
+            Debugging.Assert(() => start != -1);
             offsetAtt.SetOffset(CorrectOffset(start), finalOffset = CorrectOffset(end));
             return true;
         }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
index aa22177..9c2f505 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharacterUtils.cs
@@ -1,5 +1,6 @@
 using J2N;
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using System;
@@ -175,8 +176,8 @@ namespace Lucene.Net.Analysis.Util
         /// <param name="length"> the number of characters in the buffer to lower case </param>
         public virtual void ToLower(char[] buffer, int offset, int length) // LUCENENET specific - marked virtual so we can override the default
         {
-            Debug.Assert(buffer.Length >= length);
-            Debug.Assert(offset <= 0 && offset <= buffer.Length);
+            Debugging.Assert(() => buffer.Length >= length);
+            Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
 
             // Slight optimization, eliminating a few method calls internally
             CultureInfo.InvariantCulture.TextInfo
@@ -206,8 +207,8 @@ namespace Lucene.Net.Analysis.Util
         /// <param name="length"> the number of characters in the buffer to lower case </param>
         public virtual void ToUpper(char[] buffer, int offset, int length) // LUCENENET specific - marked virtual so we can override the default
         {
-            Debug.Assert(buffer.Length >= length);
-            Debug.Assert(offset <= 0 && offset <= buffer.Length);
+            Debugging.Assert(() => buffer.Length >= length);
+            Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
 
             // Slight optimization, eliminating a few method calls internally
             CultureInfo.InvariantCulture.TextInfo
@@ -348,7 +349,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                Debug.Assert(buffer.Buffer.Length >= 2);
+                Debugging.Assert(() => buffer.Buffer.Length >= 2);
                 if (numChars < 2 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 2 and <= the buffer size");
@@ -469,7 +470,7 @@ namespace Lucene.Net.Analysis.Util
 
             public override bool Fill(CharacterBuffer buffer, TextReader reader, int numChars)
             {
-                Debug.Assert(buffer.Buffer.Length >= 1);
+                Debugging.Assert(() => buffer.Buffer.Length >= 1);
                 if (numChars < 1 || numChars > buffer.Buffer.Length)
                 {
                     throw new ArgumentException("numChars must be >= 1 and <= the buffer size");
@@ -532,8 +533,8 @@ namespace Lucene.Net.Analysis.Util
         {
             public override void ToLower(char[] buffer, int offset, int limit)
             {
-                Debug.Assert(buffer.Length >= limit);
-                Debug.Assert(offset <= 0 && offset <= buffer.Length);
+                Debugging.Assert(() => buffer.Length >= limit);
+                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
 
                 for (int i = offset; i < limit;)
                 {
@@ -545,8 +546,8 @@ namespace Lucene.Net.Analysis.Util
 
             public override void ToUpper(char[] buffer, int offset, int limit)
             {
-                Debug.Assert(buffer.Length >= limit);
-                Debug.Assert(offset <= 0 && offset <= buffer.Length);
+                Debugging.Assert(() => buffer.Length >= limit);
+                Debugging.Assert(() => offset <= 0 && offset <= buffer.Length);
 
                 for (int i = offset; i < limit;)
                 {
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
index 3cf6f12..e4a7086 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/RollingCharBuffer.cs
@@ -1,7 +1,8 @@
-using System;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
+using System;
 using System.Diagnostics;
 using System.IO;
-using Lucene.Net.Util;
 
 namespace Lucene.Net.Analysis.Util
 {
@@ -107,10 +108,10 @@ namespace Lucene.Net.Analysis.Util
             else
             {
                 // Cannot read from future (except by 1):
-                Debug.Assert(pos < nextPos);
+                Debugging.Assert(() => pos < nextPos);
 
                 // Cannot read from already freed past:
-                Debug.Assert(nextPos - pos <= count, "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
+                Debugging.Assert(() => nextPos - pos <= count, () => "nextPos=" + nextPos + " pos=" + pos + " count=" + count);
 
                 return buffer[GetIndex(pos)];
             }
@@ -129,15 +130,15 @@ namespace Lucene.Net.Analysis.Util
             {
                 // Wrap:
                 index += buffer.Length;
-                Debug.Assert(index >= 0);
+                Debugging.Assert(() => index >= 0);
             }
             return index;
         }
 
         public char[] Get(int posStart, int length)
         {
-            Debug.Assert(length > 0);
-            Debug.Assert(InBounds(posStart), "posStart=" + posStart + " length=" + length);
+            Debugging.Assert(() => length > 0);
+            Debugging.Assert(() => InBounds(posStart), () => "posStart=" + posStart + " length=" + length);
             //System.out.println("    buffer.Get posStart=" + posStart + " len=" + length);
 
             int startIndex = GetIndex(posStart);
@@ -165,11 +166,11 @@ namespace Lucene.Net.Analysis.Util
         /// </summary>
         public void FreeBefore(int pos)
         {
-            Debug.Assert(pos >= 0);
-            Debug.Assert(pos <= nextPos);
+            Debugging.Assert(() => pos >= 0);
+            Debugging.Assert(() => pos <= nextPos);
             int newCount = nextPos - pos;
-            Debug.Assert(newCount <= count, "newCount=" + newCount + " count=" + count);
-            Debug.Assert(newCount <= buffer.Length, "newCount=" + newCount + " buf.length=" + buffer.Length);
+            Debugging.Assert(() => newCount <= count, () => "newCount=" + newCount + " count=" + count);
+            Debugging.Assert(() => newCount <= buffer.Length, () => "newCount=" + newCount + " buf.length=" + buffer.Length);
             count = newCount;
         }
     }
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
index f4e848d..23cbfae 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/SegmentingTokenizerBase.cs
@@ -1,6 +1,7 @@
 #if FEATURE_BREAKITERATOR
 using ICU4N.Text;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using System.IO;
@@ -183,7 +184,7 @@ namespace Lucene.Net.Analysis.Util
         /// commons-io's readFully, but without bugs if offset != 0 </summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            Debug.Assert(length >= 0, "length must not be negative: " + length);
+            Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
index 9164e95..9c8d61c 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/StemmerUtil.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Diagnostics;
 
 namespace Lucene.Net.Analysis.Util
@@ -116,7 +117,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int Delete(char[] s, int pos, int len)
         {
-            Debug.Assert(pos < len);
+            Debugging.Assert(() => pos < len);
             if (pos < len - 1) // don't arraycopy if asked to delete last character
             {
                 Array.Copy(s, pos + 1, s, pos, len - pos - 1);
@@ -134,7 +135,7 @@ namespace Lucene.Net.Analysis.Util
         /// <returns> length of input buffer after deletion </returns>
         public static int DeleteN(char[] s, int pos, int len, int nChars)
         {
-            Debug.Assert(pos + nChars <= len);
+            Debugging.Assert(() => pos + nChars <= len);
             if (pos + nChars < len) // don't arraycopy if asked to delete the last characters
             {
                 Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
index e04dc5f..981e073 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/ICUNormalizer2CharFilter.cs
@@ -9,6 +9,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Text;
 using ExceptionToClassNameConventionAttribute = Lucene.Net.Support.ExceptionToClassNameConventionAttribute;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Analysis.Icu
 {
@@ -127,7 +128,7 @@ namespace Lucene.Net.Analysis.Icu
                 bool hasRemainingChars = CharacterUtils.GetInstance(LuceneVersion.LUCENE_CURRENT).Fill(tmpBuffer, m_input);
 #pragma warning restore 612, 618
 
-                Debug.Assert(tmpBuffer.Offset == 0);
+                Debugging.Assert(() => tmpBuffer.Offset == 0);
                 inputBuffer.Append(tmpBuffer.Buffer, 0, tmpBuffer.Length);
 
                 if (hasRemainingChars == false)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
index 2ae6ce6..213fa2f 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizer.cs
@@ -3,6 +3,7 @@ using ICU4N;
 using ICU4N.Text;
 using Lucene.Net.Analysis.Icu.TokenAttributes;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -193,7 +194,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
         /// <summary>commons-io's readFully, but without bugs if offset != 0</summary>
         private static int Read(TextReader input, char[] buffer, int offset, int length)
         {
-            Debug.Assert(length >= 0, "length must not be negative: " + length);
+            Debugging.Assert(() => length >= 0, () => "length must not be negative: " + length);
 
             int remaining = length;
             while (remaining > 0)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
index ea93354..c487089 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
@@ -3,6 +3,7 @@ using ICU4N;
 using ICU4N.Globalization;
 using ICU4N.Text;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using System;
@@ -101,7 +102,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public virtual void Inform(IResourceLoader loader)
         {
-            Debug.Assert(tailored != null, "init must be called first!");
+            Debugging.Assert(() => tailored != null, () => "init must be called first!");
             if (tailored.Count == 0)
             {
                 config = new DefaultICUTokenizerConfig(cjkAsWords, myanmarAsWords);
@@ -161,7 +162,7 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
 
         public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
         {
-            Debug.Assert(config != null, "inform must be called first!");
+            Debugging.Assert(() => config != null, () => "inform must be called first!");
             return new ICUTokenizer(factory, input, config);
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
index 0ae2780..04ca422 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/TokenInfoFST.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Util.Fst;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util.Fst;
 using System.Diagnostics;
 
 namespace Lucene.Net.Analysis.Ja.Dict
@@ -74,7 +75,7 @@ namespace Lucene.Net.Analysis.Ja.Dict
         {
             if (useCache && ch >= 0x3040 && ch <= cacheCeiling)
             {
-                Debug.Assert(ch != FST.END_LABEL);
+                Debugging.Assert(() => ch != FST.END_LABEL);
                 FST.Arc<long?> result = rootCache[ch - 0x3040];
                 if (result == null)
                 {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
index bcbc81d..a1e1fa9 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
@@ -89,8 +89,8 @@ namespace Lucene.Net.Analysis.Ja
                 string toNodeID = GetNodeID(pos, bestIDX);
                 string fromNodeID = GetNodeID(backPos, backIDX);
 
-                Debug.Assert(!bestPathMap.ContainsKey(fromNodeID));
-                Debug.Assert(!bestPathMap.Values.Contains(toNodeID));
+                Debugging.Assert(!bestPathMap.ContainsKey(fromNodeID));
+                Debugging.Assert(!bestPathMap.Values.Contains(toNodeID));
                 bestPathMap[fromNodeID] = toNodeID;
                 pos = backPos;
                 bestIDX = backIDX;
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
index e615a05..ad243f4 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
@@ -133,7 +133,7 @@ namespace Lucene.Net.Analysis.Ja
 
             // Make katakana dakuten map from hiragana map
             char codePointDifference = (char)('\u30ab' - '\u304b'); // カ - か
-            Debug.Assert(h2d.Length == k2d.Length);
+            Debugging.Assert(h2d.Length == k2d.Length);
             for (int i = 0; i < k2d.Length; i++)
             {
                 k2d[i] = (char)(h2d[i] + codePointDifference);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
index cfd9a9a..d9d2293 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis.Ja
             int leftID = dict.GetLeftId(wordID);
             int leastCost = int.MaxValue;
             int leastIDX = -1;
-            Debug.Assert(fromPosData.count > 0);
+            Debugging.Assert(fromPosData.count > 0);
             for (int idx = 0; idx < fromPosData.count; idx++)
             {
                 // Cost is path cost so far, plus word cost (added at
@@ -356,7 +356,7 @@ namespace Lucene.Net.Analysis.Ja
             }
 
             //positions.get(endPos).add(leastCost, dict.getRightId(wordID), fromPosData.pos, leastIDX, wordID, type);
-            Debug.Assert(leftID == dict.GetRightId(wordID));
+            Debugging.Assert(leftID == dict.GetRightId(wordID));
             positions.Get(endPos).Add(leastCost, leftID, fromPosData.pos, leastIDX, wordID, type);
         }
 
@@ -387,7 +387,7 @@ namespace Lucene.Net.Analysis.Ja
             int position = token.Position;
             int length = token.Length;
             ClearAttributes();
-            Debug.Assert(length > 0);
+            Debugging.Assert(length > 0);
             //System.out.println("off=" + token.getOffset() + " len=" + length + " vs " + token.getSurfaceForm().length);
             termAtt.CopyBuffer(token.SurfaceForm, token.Offset, length);
             offsetAtt.SetOffset(CorrectOffset(position), CorrectOffset(position + length));
@@ -402,7 +402,7 @@ namespace Lucene.Net.Analysis.Ja
             }
             else
             {
-                Debug.Assert(token.Position > lastTokenPos);
+                Debugging.Assert(token.Position > lastTokenPos);
                 posIncAtt.PositionIncrement = 1;
                 posLengthAtt.PositionLength = 1;
             }
@@ -511,7 +511,7 @@ namespace Lucene.Net.Analysis.Ja
                     }
 
                     // We will always have at least one live path:
-                    Debug.Assert(leastIDX != -1);
+                    Debugging.Assert(leastIDX != -1);
 
                     // Second pass: prune all but the best path:
                     for (int pos2 = pos; pos2 < positions.GetNextPos(); pos2++)
@@ -544,7 +544,7 @@ namespace Lucene.Net.Analysis.Ja
                     if (pos != leastPosData.pos)
                     {
                         // We jumped into a future position:
-                        Debug.Assert(pos < leastPosData.pos);
+                        Debugging.Assert(pos < leastPosData.pos);
                         pos = leastPosData.pos;
                     }
 
@@ -913,10 +913,10 @@ namespace Lucene.Net.Analysis.Ja
             {
                 //System.out.println("BT: back pos=" + pos + " bestIDX=" + bestIDX);
                 Position posData = positions.Get(pos);
-                Debug.Assert(bestIDX < posData.count);
+                Debugging.Assert(bestIDX < posData.count);
 
                 int backPos = posData.backPos[bestIDX];
-                Debug.Assert(backPos >= lastBackTracePos, "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
+                Debugging.Assert(backPos >= lastBackTracePos, "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
                 int length = pos - backPos;
                 JapaneseTokenizerType backType = posData.backType[bestIDX];
                 int backID = posData.backID[bestIDX];
@@ -989,7 +989,7 @@ namespace Lucene.Net.Analysis.Ja
                         if (leastIDX != -1 && leastCost <= maxCost && posData.backPos[leastIDX] != backPos)
                         {
                             // We should have pruned the altToken from the graph:
-                            Debug.Assert(posData.backPos[leastIDX] != backPos);
+                            Debugging.Assert(posData.backPos[leastIDX] != backPos);
 
                             // Save the current compound token, to output when
                             // this alternate path joins back:
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Analysis.Ja
                 }
 
                 int offset = backPos - lastBackTracePos;
-                Debug.Assert(offset >= 0);
+                Debugging.Assert(offset >= 0);
 
                 if (altToken != null && altToken.Position >= backPos)
                 {
@@ -1035,7 +1035,7 @@ namespace Lucene.Net.Analysis.Ja
                     // The pruning we did when we created the altToken
                     // ensures that the back trace will align back with
                     // the start of the altToken:
-                    Debug.Assert(altToken.Position == backPos, altToken.Position + " vs " + backPos);
+                    Debugging.Assert(altToken.Position == backPos, altToken.Position + " vs " + backPos);
 
                     // NOTE: not quite right: the compound token may
                     // have had all punctuation back traced so far, but
@@ -1060,7 +1060,7 @@ namespace Lucene.Net.Analysis.Ja
                         {
                             Console.WriteLine("    discard all-punctuation altToken=" + altToken);
                         }
-                        Debug.Assert(discardPunctuation);
+                        Debugging.Assert(discardPunctuation);
                     }
                     altToken = null;
                 }
@@ -1355,7 +1355,7 @@ namespace Lucene.Net.Analysis.Ja
         {
             count = 0;
             // forwardCount naturally resets after it runs:
-            Debug.Assert(forwardCount == 0, "pos=" + pos + " forwardCount=" + forwardCount);
+            Debugging.Assert(forwardCount == 0, "pos=" + pos + " forwardCount=" + forwardCount);
         }
     }
 
@@ -1432,13 +1432,13 @@ namespace Lucene.Net.Analysis.Ja
                     nextWrite = 0;
                 }
                 // Should have already been reset:
-                Debug.Assert(positions[nextWrite].count == 0);
+                Debugging.Assert(positions[nextWrite].count == 0);
                 positions[nextWrite++].pos = nextPos++;
                 count++;
             }
-            Debug.Assert(InBounds(pos));
+            Debugging.Assert(InBounds(pos));
             int index = GetIndex(pos);
-            Debug.Assert(positions[index].pos == pos);
+            Debugging.Assert(positions[index].pos == pos);
             return positions[index];
         }
 
@@ -1466,8 +1466,8 @@ namespace Lucene.Net.Analysis.Ja
         public void FreeBefore(int pos)
         {
             int toFree = count - (nextPos - pos);
-            Debug.Assert(toFree >= 0);
-            Debug.Assert(toFree <= count);
+            Debugging.Assert(toFree >= 0);
+            Debugging.Assert(toFree <= count);
             int index = nextWrite - count;
             if (index < 0)
             {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
index 4bc8ebf..cfbfb3d 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
@@ -1,6 +1,7 @@
 using J2N.IO;
 using Lucene.Net.Analysis.Ja.Dict;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
@@ -61,7 +62,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             for (int i = 4; i < 8; i++)
             {
                 string part = entry[i];
-                Debug.Assert(part.Length > 0);
+                Debugging.Assert(part.Length > 0);
                 if (!"*".Equals(part, StringComparison.Ordinal))
                 {
                     if (sb.Length > 0)
@@ -118,8 +119,8 @@ namespace Lucene.Net.Analysis.Ja.Util
                 flags |= BinaryDictionary.HAS_PRONUNCIATION;
             }
 
-            Debug.Assert(leftId == rightId);
-            Debug.Assert(leftId < 4096); // there are still unused bits
+            Debugging.Assert(leftId == rightId);
+            Debugging.Assert(leftId < 4096); // there are still unused bits
                                          // add pos mapping
             int toFill = 1 + leftId - posDict.Count;
             for (int i = 0; i < toFill; i++)
@@ -128,7 +129,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
 
             string existing = posDict[leftId];
-            Debug.Assert(existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
+            Debugging.Assert(existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
             posDict[leftId] = fullPOSData;
 
             m_buffer.PutInt16((short)(leftId << 3 | flags));
@@ -136,7 +137,7 @@ namespace Lucene.Net.Analysis.Ja.Util
 
             if ((flags & BinaryDictionary.HAS_BASEFORM) != 0)
             {
-                Debug.Assert(baseForm.Length < 16);
+                Debugging.Assert(baseForm.Length < 16);
                 int shared = SharedPrefix(entry[0], baseForm);
                 int suffix = baseForm.Length - shared;
                 m_buffer.Put((byte)(shared << 4 | suffix));
@@ -237,11 +238,11 @@ namespace Lucene.Net.Analysis.Ja.Util
 
         public virtual void AddMapping(int sourceId, int wordId)
         {
-            Debug.Assert(wordId > lastWordId, "words out of order: " + wordId + " vs lastID: " + lastWordId);
+            Debugging.Assert(() => wordId > lastWordId, () => "words out of order: " + wordId + " vs lastID: " + lastWordId);
 
             if (sourceId > lastSourceId)
             {
-                Debug.Assert(sourceId > lastSourceId, "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
+                Debugging.Assert(() => sourceId > lastSourceId, () => "source ids out of order: lastSourceId=" + lastSourceId + " vs sourceId=" + sourceId);
                 targetMapOffsets = ArrayUtil.Grow(targetMapOffsets, sourceId + 1);
                 for (int i = lastSourceId + 1; i <= sourceId; i++)
                 {
@@ -250,7 +251,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
             else
             {
-                Debug.Assert(sourceId == lastSourceId);
+                Debugging.Assert(() => sourceId == lastSourceId);
             }
 
             targetMap = ArrayUtil.Grow(targetMap, targetMapEndOffset + 1);
@@ -305,7 +306,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 for (int ofs = 0; ofs < targetMapEndOffset; ofs++)
                 {
                     int val = targetMap[ofs], delta = val - prev;
-                    Debug.Assert(delta >= 0);
+                    Debugging.Assert(() => delta >= 0);
                     if (ofs == targetMapOffsets[sourceId])
                     {
                         @out.WriteVInt32((delta << 1) | 0x01);
@@ -317,7 +318,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     }
                     prev += delta;
                 }
-                Debug.Assert(sourceId == numSourceIds, "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
+                Debugging.Assert(() => sourceId == numSourceIds, () => "sourceId:" + sourceId + " != numSourceIds:" + numSourceIds);
             }
         }
 
@@ -341,7 +342,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     else
                     {
                         string[] data = CSVUtil.Parse(s);
-                        Debug.Assert(data.Length == 3, "malformed pos/inflection: " + s);
+                        Debugging.Assert(() => data.Length == 3, () => "malformed pos/inflection: " + s);
                         @out.WriteString(data[0]);
                         @out.WriteString(data[1]);
                         @out.WriteString(data[2]);
@@ -370,7 +371,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                     @out.WriteByte(m_buffer.Get());
                 }
 
-                Debug.Assert(m_buffer.Remaining == 0L);
+                Debugging.Assert(() => m_buffer.Remaining == 0L);
             }
         }
     }
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
index 1d7dbb0..d7acc77 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
@@ -41,12 +42,12 @@ namespace Lucene.Net.Analysis.Ja.Util
                 string line = streamReader.ReadLine();
                 string[] dimensions = whiteSpaceRegex.Split(line).TrimEnd();
 
-                Debug.Assert(dimensions.Length == 2);
+                Debugging.Assert(() => dimensions.Length == 2);
 
                 int forwardSize = int.Parse(dimensions[0], CultureInfo.InvariantCulture);
                 int backwardSize = int.Parse(dimensions[1], CultureInfo.InvariantCulture);
 
-                Debug.Assert(forwardSize > 0 && backwardSize > 0);
+                Debugging.Assert(() => forwardSize > 0 && backwardSize > 0);
 
                 ConnectionCostsWriter costs = new ConnectionCostsWriter(forwardSize, backwardSize);
 
@@ -54,7 +55,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 {
                     string[] fields = whiteSpaceRegex.Split(line).TrimEnd();
 
-                    Debug.Assert(fields.Length == 3);
+                    Debugging.Assert(fields.Length == 3);
 
                     int forwardId = int.Parse(fields[0], CultureInfo.InvariantCulture);
                     int backwardId = int.Parse(fields[1], CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
index 91e4df8..9eea786 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsWriter.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Analysis.Ja.Dict;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using System.Diagnostics;
 using System.IO;
@@ -62,10 +63,10 @@ namespace Lucene.Net.Analysis.Ja.Util
                 @out.WriteVInt32(forwardSize);
                 @out.WriteVInt32(backwardSize);
                 int last = 0;
-                Debug.Assert(costs.Length == backwardSize);
+                Debugging.Assert(() => costs.Length == backwardSize);
                 foreach (short[] a in costs)
                 {
-                    Debug.Assert(a.Length == forwardSize);
+                    Debugging.Assert(() => a.Length == forwardSize);
                     for (int i = 0; i < a.Length; i++)
                     {
                         int delta = (int)a[i] - last;
diff --git a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
index dc9cef7..4a17a01 100644
--- a/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
+++ b/src/Lucene.Net.Analysis.Phonetic/BeiderMorseFilter.cs
@@ -1,7 +1,7 @@
 // lucene version compatibility level: 4.8.1
 using Lucene.Net.Analysis.Phonetic.Language.Bm;
 using Lucene.Net.Analysis.TokenAttributes;
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 using System.Text.RegularExpressions;
 
 namespace Lucene.Net.Analysis.Phonetic
@@ -85,7 +85,7 @@ namespace Lucene.Net.Analysis.Phonetic
 
             if (matcher.Success)
             {
-                Debug.Assert(state != null && encoded != null);
+                Debugging.Assert(() => state != null && encoded != null);
                 RestoreState(state);
 
                 int start = matcher.Index;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
index 0ac466c..d962a24 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
@@ -1,7 +1,7 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 
@@ -42,7 +42,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Utils
                                IList<TokenFilterFactory> tokenFilterFactories)
         {
             this.charFilterFactories = charFilterFactories;
-            Debug.Assert(null != tokenizerFactory);
+            Debugging.Assert(() => null != tokenizerFactory);
             this.tokenizerFactory = tokenizerFactory;
             this.tokenFilterFactories = tokenFilterFactories;
         }
diff --git a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
index 2ed4e12..5a357c8 100644
--- a/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
+++ b/src/Lucene.Net.Benchmark/Quality/QualityStats.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -241,7 +242,7 @@ namespace Lucene.Net.Benchmarks.Quality
                     }
                 }
             }
-            Debug.Assert(m> 0, "Fishy: no \"good\" queries!");
+            Debugging.Assert(() => m > 0, () => "Fishy: no \"good\" queries!");
             // take average: times go by all queries, other measures go by "good" queries only.
             avg.searchTime /= stats.Length;
             avg.docNamesExtractTime /= stats.Length;
diff --git a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
index c6b5d21..2f8ba27 100644
--- a/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
+++ b/src/Lucene.Net.Benchmark/Quality/Trec/TrecJudge.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -72,7 +73,7 @@ namespace Lucene.Net.Benchmarks.Quality.Trec
                     st.MoveNext();
                     bool relevant = !zero.Equals(st.Current, StringComparison.Ordinal);
                     // LUCENENET: don't call st.NextToken() unless the condition fails.
-                    Debug.Assert(st.RemainingTokens == 0, "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
+                    Debugging.Assert(() => st.RemainingTokens == 0, () => "wrong format: " + line + "  next: " + (st.MoveNext() ? st.Current : ""));
                     if (relevant)
                     { // only keep relevant docs
                         if (curr == null || !curr.queryID.Equals(queryID, StringComparison.Ordinal))
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
index f3c07dc..e33c4a9 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -126,7 +127,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 {
                     int field = input.ReadVInt32();
                     long numTerms = input.ReadVInt64();
-                    Debug.Assert(numTerms >= 0);
+                    Debugging.Assert(() => numTerms >= 0);
                     long termsStartPointer = input.ReadVInt64();
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : input.ReadVInt64();
@@ -233,7 +234,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
         public override Terms GetTerms(string field)
         {
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
 
             FieldReader result;
             fields.TryGetValue(field, out result);
@@ -257,7 +258,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldReader(BlockTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int longsSize)
             {
-                Debug.Assert(numTerms > 0);
+                Debugging.Assert(() => numTerms > 0);
 
                 this.outerInstance = outerInstance;
 
@@ -448,7 +449,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                         // Block must exist since, at least, the indexed term
                         // is in the block:
-                        Debug.Assert(result);
+                        Debugging.Assert(() => result);
 
                         indexIsCurrent = true;
                         didIndexNext = false;
@@ -536,7 +537,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 // Target's prefix is before the common prefix
                                 // of this block, so we position to start of
                                 // block and return NOT_FOUND:
-                                Debug.Assert(state.TermBlockOrd == 0);
+                                Debugging.Assert(() => state.TermBlockOrd == 0);
 
                                 int suffix = termSuffixesReader.ReadVInt32();
                                 term.Length = termBlockPrefix + suffix;
@@ -641,7 +642,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // cross another index term (besides the first
                         // one) while we are scanning:
 
-                        Debug.Assert(indexIsCurrent);
+                        Debugging.Assert(() => indexIsCurrent);
 
                         if (!NextBlock())
                         {
@@ -664,7 +665,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // works properly:
                     if (seekPending)
                     {
-                        Debug.Assert(!indexIsCurrent);
+                        Debugging.Assert(() => !indexIsCurrent);
                         input.Seek(state.BlockFilePointer);
                         int pendingSeekCount = state.TermBlockOrd;
                         bool result = NextBlock();
@@ -674,12 +675,12 @@ namespace Lucene.Net.Codecs.BlockTerms
                         // Block must exist since seek(TermState) was called w/ a
                         // TermState previously returned by this enum when positioned
                         // on a real term:
-                        Debug.Assert(result);
+                        Debugging.Assert(() => result);
 
                         while (state.TermBlockOrd < pendingSeekCount)
                         {
                             BytesRef nextResult = _next();
-                            Debug.Assert(nextResult != null);
+                            Debugging.Assert(() => nextResult != null);
                         }
                         seekPending = false;
                         state.Ord = savOrd;
@@ -768,8 +769,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                 public override void SeekExact(BytesRef target, TermState otherState)
                 {
                     //System.out.println("BTR.seekExact termState target=" + target.utf8ToString() + " " + target + " this=" + this);
-                    Debug.Assert(otherState != null && otherState is BlockTermState);
-                    Debug.Assert(!doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
+                    Debugging.Assert(() => otherState != null && otherState is BlockTermState);
+                    Debugging.Assert(() => !doOrd || ((BlockTermState)otherState).Ord < outerInstance.numTerms);
                     state.CopyFrom(otherState);
                     seekPending = true;
                     indexIsCurrent = false;
@@ -793,7 +794,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                         throw new InvalidOperationException("terms index was not loaded");
                     }
 
-                    Debug.Assert(ord < outerInstance.numTerms);
+                    Debugging.Assert(() => ord < outerInstance.numTerms);
 
                     // TODO: if ord is in same terms block and
                     // after current ord, we should avoid this seek just
@@ -802,7 +803,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     bool result = NextBlock();
 
                     // Block must exist since ord < numTerms:
-                    Debug.Assert(result);
+                    Debugging.Assert(() => result);
 
                     indexIsCurrent = true;
                     didIndexNext = false;
@@ -810,7 +811,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     seekPending = false;
 
                     state.Ord = indexEnum.Ord - 1;
-                    Debug.Assert(state.Ord >= -1, "Ord=" + state.Ord);
+                    Debugging.Assert(() => state.Ord >= -1, () => "Ord=" + state.Ord);
                     term.CopyBytes(indexEnum.Term);
 
                     // Now, scan:
@@ -818,9 +819,9 @@ namespace Lucene.Net.Codecs.BlockTerms
                     while (left > 0)
                     {
                         BytesRef term = _next();
-                        Debug.Assert(term != null);
+                        Debugging.Assert(() => term != null);
                         left--;
-                        Debug.Assert(indexIsCurrent);
+                        Debugging.Assert(() => indexIsCurrent);
                     }
                 }
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
index 853fe15..63a82a9 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/BlockTermsWriter.cs
@@ -1,10 +1,10 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 
 namespace Lucene.Net.Codecs.BlockTerms
 {
@@ -70,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             public FieldMetaData(FieldInfo fieldInfo, long numTerms, long termsStartPointer, long sumTotalTermFreq,
                 long sumDocFreq, int docCount, int int64sSize)
             {
-                Debug.Assert(numTerms > 0);
+                Debugging.Assert(() => numTerms > 0);
 
                 FieldInfo = fieldInfo;
                 TermsStartPointer = termsStartPointer;
@@ -123,7 +123,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         public override TermsConsumer AddField(FieldInfo field)
         {
             //System.out.println("\nBTW.addField seg=" + segment + " field=" + field.name);
-            Debug.Assert(currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             TermsIndexWriterBase.FieldWriter fieldIndexWriter = termsIndexWriter.AddField(field, m_output.GetFilePointer());
             return new TermsWriter(this, fieldIndexWriter, field, postingsWriter);
@@ -235,7 +235,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debug.Assert(stats.DocFreq > 0);
+                Debugging.Assert(() => stats.DocFreq > 0);
                 //System.out.println("BTW: finishTerm term=" + fieldInfo.name + ":" + text.utf8ToString() + " " + text + " seg=" + segment + " df=" + stats.docFreq);
 
                 bool isIndexTerm = fieldIndexWriter.CheckIndexTerm(text, stats);
@@ -302,8 +302,8 @@ namespace Lucene.Net.Codecs.BlockTerms
 
             private int SharedPrefix(BytesRef term1, BytesRef term2)
             {
-                Debug.Assert(term1.Offset == 0);
-                Debug.Assert(term2.Offset == 0);
+                Debugging.Assert(() => term1.Offset == 0);
+                Debugging.Assert(() => term2.Offset == 0);
                 int pos1 = 0;
                 int pos1End = pos1 + Math.Min(term1.Length, term2.Length);
                 int pos2 = 0;
@@ -359,7 +359,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 for (int termCount = 0; termCount < pendingCount; termCount++)
                 {
                     BlockTermState state = pendingTerms[termCount].State;
-                    Debug.Assert(state != null);
+                    Debugging.Assert(() => state != null);
                     bytesWriter.WriteVInt32(state.DocFreq);
                     if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                     {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
index d28b331..bf5ba28 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -69,7 +70,7 @@ namespace Lucene.Net.Codecs.BlockTerms
         {
             this.termComp = termComp;
 
-            Debug.Assert(indexDivisor == -1 || indexDivisor > 0);
+            Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
 
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, FixedGapTermsIndexWriter.TERMS_INDEX_EXTENSION), context);
 
@@ -100,7 +101,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // In case terms index gets loaded, later, on demand
                     totalIndexInterval = indexInterval * indexDivisor;
                 }
-                Debug.Assert(totalIndexInterval > 0);
+                Debugging.Assert(() => totalIndexInterval > 0);
 
                 SeekDir(input, dirOffset);
 
@@ -189,7 +190,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int lo = 0;          // binary search
                 int hi = fieldIndex.numIndexTerms - 1;
-                Debug.Assert(outerInstance.totalIndexInterval > 0, "totalIndexInterval=" + outerInstance.totalIndexInterval);
+                Debugging.Assert(() => outerInstance.totalIndexInterval > 0, () => "totalIndexInterval=" + outerInstance.totalIndexInterval);
 
                 while (hi >= lo)
                 {
@@ -210,7 +211,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                     }
                     else
                     {
-                        Debug.Assert(mid >= 0);
+                        Debugging.Assert(() => mid >= 0);
                         ord = mid * outerInstance.totalIndexInterval;
                         return fieldIndex.termsStart + fieldIndex.termsDictOffsets.Get(mid);
                     }
@@ -218,7 +219,7 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                 if (hi < 0)
                 {
-                    Debug.Assert(hi == -1);
+                    Debugging.Assert(() => hi == -1);
                     hi = 0;
                 }
 
@@ -251,7 +252,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             {
                 int idx = (int)(ord / outerInstance.totalIndexInterval);
                 // caller must ensure ord is in bounds
-                Debug.Assert(idx < fieldIndex.numIndexTerms);
+                Debugging.Assert(() => idx < fieldIndex.numIndexTerms);
                 long offset = fieldIndex.termOffsets.Get(idx);
                 int length = (int)(fieldIndex.termOffsets.Get(1 + idx) - offset);
                 outerInstance.termBytesReader.FillSlice(term, fieldIndex.termBytesStart + offset, length);
@@ -327,11 +328,11 @@ namespace Lucene.Net.Codecs.BlockTerms
                     // -1 is passed to mean "don't load term index", but
                     // if we are then later loaded it's overwritten with
                     // a real value
-                    Debug.Assert(outerInstance.outerInstance.indexDivisor > 0);
+                    Debugging.Assert(() => outerInstance.outerInstance.indexDivisor > 0);
 
                     this.numIndexTerms = 1 + (numIndexTerms - 1) / outerInstance.outerInstance.indexDivisor;
 
-                    Debug.Assert(this.numIndexTerms > 0, "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
+                    Debugging.Assert(() => this.numIndexTerms > 0, () => "numIndexTerms=" + numIndexTerms + " indexDivisor=" + outerInstance.outerInstance.indexDivisor);
 
                     if (outerInstance.outerInstance.indexDivisor == 1)
                     {
@@ -344,11 +345,11 @@ namespace Lucene.Net.Codecs.BlockTerms
 
                             // records offsets into main terms dict file
                             termsDictOffsets = PackedInt32s.GetReader(clone);
-                            Debug.Assert(termsDictOffsets.Count == numIndexTerms);
+                            Debugging.Assert(() => termsDictOffsets.Count == numIndexTerms);
 
                             // records offsets into byte[] term data
                             termOffsets = PackedInt32s.GetReader(clone);
-                            Debug.Assert(termOffsets.Count == 1 + numIndexTerms);
+                            Debugging.Assert(() => termOffsets.Count == 1 + numIndexTerms);
                         }
                         finally
                         {
@@ -397,8 +398,8 @@ namespace Lucene.Net.Codecs.BlockTerms
                                 int numTermBytes = (int)(nextTermOffset - termOffset);
 
                                 clone.Seek(indexStart + termOffset);
-                                Debug.Assert(indexStart + termOffset < clone.Length, "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
-                                Debug.Assert(indexStart + termOffset + numTermBytes < clone.Length);
+                                Debugging.Assert(() => indexStart + termOffset < clone.Length, () => "indexStart=" + indexStart + " termOffset=" + termOffset + " len=" + clone.Length);
+                                Debugging.Assert(() => indexStart + termOffset + numTermBytes < clone.Length);
 
                                 outerInstance.outerInstance.termBytes.Copy(clone, numTermBytes);
                                 termOffsetUpto += numTermBytes;
diff --git a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
index 79caf43..d0f8f5d 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/FixedGapTermsIndexWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -186,7 +187,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 lastTermsPointer = termsFilePointer;
 
                 // save term length (in bytes)
-                Debug.Assert(indexedTermLength <= short.MaxValue);
+                Debugging.Assert(() => indexedTermLength <= short.MaxValue);
                 termLengths[numIndexTerms] = (short)indexedTermLength;
                 totTermLength += indexedTermLength;
 
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
index 29f226b..5fcfd0e 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -5,7 +6,6 @@ using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 
 namespace Lucene.Net.Codecs.BlockTerms
 {
@@ -55,7 +55,7 @@ namespace Lucene.Net.Codecs.BlockTerms
             input = dir.OpenInput(IndexFileNames.SegmentFileName(segment, segmentSuffix, VariableGapTermsIndexWriter.TERMS_INDEX_EXTENSION), new IOContext(context, true));
             //this.segment = segment; // LUCENENET: Not used
             bool success = false;
-            Debug.Assert(indexDivisor == -1 || indexDivisor > 0);
+            Debugging.Assert(() => indexDivisor == -1 || indexDivisor > 0);
 
             try
             {
diff --git a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
index ced4aa9..5812245 100644
--- a/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
+++ b/src/Lucene.Net.Codecs/BlockTerms/VariableGapTermsIndexWriter.cs
@@ -1,10 +1,10 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 
 namespace Lucene.Net.Codecs.BlockTerms
 {
@@ -292,7 +292,7 @@ namespace Lucene.Net.Codecs.BlockTerms
                 if (text.Length == 0)
                 {
                     // We already added empty string in ctor
-                    Debug.Assert(termsFilePointer == startTermsFilePointer);
+                    Debugging.Assert(() => termsFilePointer == startTermsFilePointer);
                     return;
                 }
                 int lengthSave = text.Length;
diff --git a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
index 3a99cda..c6b18d3 100644
--- a/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Bloom/BloomFilteringPostingsFormat.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -379,7 +380,7 @@ namespace Lucene.Net.Codecs.Bloom
                 var bloomFilter = outerInstance._bloomFilterFactory.GetSetForField(_state, field);
                 if (bloomFilter != null)
                 {
-                    Debug.Assert((_bloomFilters.ContainsKey(field) == false));
+                    Debugging.Assert(() => (_bloomFilters.ContainsKey(field) == false));
 
                     _bloomFilters.Add(field, bloomFilter);
                     return new WrappedTermsConsumer(_delegateFieldsConsumer.AddField(field), bloomFilter);
diff --git a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
index 4933288..5b7e804 100644
--- a/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
+++ b/src/Lucene.Net.Codecs/Bloom/FuzzySet.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
@@ -227,7 +228,7 @@ namespace Lucene.Net.Codecs.Bloom
 
         private ContainsResult MayContainValue(int positiveHash)
         {
-            Debug.Assert((positiveHash >= 0));
+            Debugging.Assert(() => (positiveHash >= 0));
 
             // Bloom sizes are always base 2 and so can be ANDed for a fast modulo
             var pos = positiveHash & _bloomSize;
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
index ce02b7e..400de2e 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexInput.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using System.Diagnostics;
 
@@ -108,7 +109,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             internal virtual void Seek(long fp, int upto)
             {
-                Debug.Assert(upto < blockSize);
+                Debugging.Assert(() => upto < blockSize);
                 if (seekPending || fp != lastBlockFP)
                 {
                     pendingFP = fp;
@@ -172,7 +173,7 @@ namespace Lucene.Net.Codecs.IntBlock
                         fp += indexIn.ReadVInt64();
                     }
                 }
-                Debug.Assert(upto < outerInstance.m_blockSize);
+                Debugging.Assert(() => upto < outerInstance.m_blockSize);
             }
 
             public override void Seek(Int32IndexInput.Reader other)
diff --git a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
index bc2a0c7..feb98e0 100644
--- a/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/FixedIntBlockIndexOutput.cs
@@ -1,6 +1,6 @@
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
-using System.Diagnostics;
 
 namespace Lucene.Net.Codecs.IntBlock
 {
@@ -101,7 +101,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    Debug.Assert(upto >= lastUpto);
+                    Debugging.Assert(() => upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
index 123cc87..89c956d 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexInput.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using System.Diagnostics;
@@ -117,7 +118,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 // TODO: should we do this in real-time, not lazy?
                 pendingFP = fp;
                 pendingUpto = upto;
-                Debug.Assert(pendingUpto >= 0, "pendingUpto=" + pendingUpto);
+                Debugging.Assert(() => pendingUpto >= 0, () => "pendingUpto=" + pendingUpto);
                 seekPending = true;
             }
 
diff --git a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
index 0b4eb5f..1ef5b83 100644
--- a/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
+++ b/src/Lucene.Net.Codecs/IntBlock/VariableIntBlockIndexOutput.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Codecs.Sep;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using System.Diagnostics;
 
@@ -106,7 +107,7 @@ namespace Lucene.Net.Codecs.IntBlock
 
             public override void Write(DataOutput indexOut, bool absolute)
             {
-                Debug.Assert(upto >= 0);
+                Debugging.Assert(() => upto >= 0);
                 if (absolute)
                 {
                     indexOut.WriteVInt32(upto);
@@ -115,7 +116,7 @@ namespace Lucene.Net.Codecs.IntBlock
                 else if (fp == lastFP)
                 {
                     // same block
-                    Debug.Assert(upto >= lastUpto);
+                    Debugging.Assert(() => upto >= lastUpto);
                     int uptoDelta = upto - lastUpto;
                     indexOut.WriteVInt32(uptoDelta << 1 | 1);
                 }
@@ -135,7 +136,7 @@ namespace Lucene.Net.Codecs.IntBlock
             hitExcDuringWrite = true;
             upto -= Add(v) - 1;
             hitExcDuringWrite = false;
-            Debug.Assert(upto >= 0);
+            Debugging.Assert(() => upto >= 0);
         }
 
         protected override void Dispose(bool disposing)
@@ -151,7 +152,7 @@ namespace Lucene.Net.Codecs.IntBlock
                     while (upto > stuffed)
                     {
                         upto -= Add(0) - 1;
-                        Debug.Assert(upto >= 0);
+                        Debugging.Assert(() => upto >= 0);
                         stuffed += 1;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
index 46839e0..51e8238 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -371,7 +372,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                     else
                     { 
-                        Debug.Assert(false);
+                        Debugging.Assert(() => false);
                         return false;
                     }
                 }
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
index bf5fa2e..4cd0dda 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
@@ -1,4 +1,5 @@
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -551,7 +552,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        Debug.Assert(length % 8 == 0);
+                        Debugging.Assert(() => length % 8 == 0);
                         var bits = new long[(int)length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
index b92fb41..16a0e4d 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectPostingsFormat.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
@@ -588,7 +589,7 @@ namespace Lucene.Net.Codecs.Memory
 
                             upto++;
                         }
-                        Debug.Assert(upto == docFreq);
+                        Debugging.Assert(() => upto == docFreq);
                         ent = new HighFreqTerm(docs, freqs, positions, payloads, totalTermFreq);
                     }
 
@@ -624,7 +625,7 @@ namespace Lucene.Net.Codecs.Memory
                     }
                 }
                 this.skipOffsets[numTerms] = skipOffset;
-                Debug.Assert(skipOffset == skipCount);
+                Debugging.Assert(() => skipOffset == skipCount);
             }
 
             /// <summary>Returns approximate RAM bytes used. </summary>
@@ -737,7 +738,7 @@ namespace Lucene.Net.Codecs.Memory
 
             private void FinishSkips()
             {
-                Debug.Assert(count == terms.Length);
+                Debugging.Assert(() => count == terms.Length);
                 int lastTermOffset = termOffsets[count - 1];
                 int lastTermLength = termOffsets[count] - lastTermOffset;
 
@@ -971,7 +972,7 @@ namespace Lucene.Net.Codecs.Memory
                 {
                     termOrd = (int) ((OrdTermState) state).Ord;
                     SetTerm();
-                    Debug.Assert(term.Equals(scratch));
+                    Debugging.Assert(() => term.Equals(scratch));
                 }
 
                 public override BytesRef Term => scratch;
@@ -1206,13 +1207,13 @@ namespace Lucene.Net.Codecs.Memory
                                 while (label > states[i].transitionMax)
                                 {
                                     states[i].transitionUpto++;
-                                    Debug.Assert(states[i].transitionUpto < states[i].transitions.Length);
+                                    Debugging.Assert(() => states[i].transitionUpto < states[i].transitions.Length);
                                     states[i].transitionMin = states[i].transitions[states[i].transitionUpto].Min;
                                     states[i].transitionMax = states[i].transitions[states[i].transitionUpto].Max;
-                                    Debug.Assert(states[i].transitionMin >= 0);
-                                    Debug.Assert(states[i].transitionMin <= 255);
-                                    Debug.Assert(states[i].transitionMax >= 0);
-                                    Debug.Assert(states[i].transitionMax <= 255);
+                                    Debugging.Assert(() => states[i].transitionMin >= 0);
+                                    Debugging.Assert(() => states[i].transitionMin <= 255);
+                                    Debugging.Assert(() => states[i].transitionMax >= 0);
+                                    Debugging.Assert(() => states[i].transitionMax <= 255);
                                 }
 
                                 // Skip forwards until we find a term matching
@@ -1253,7 +1254,7 @@ namespace Lucene.Net.Codecs.Memory
                                         //   System.out.println("  no match; already beyond; return termOrd=" + termOrd);
                                         // }
                                         stateUpto -= skipUpto;
-                                        Debug.Assert(stateUpto >= 0);
+                                        Debugging.Assert(() => stateUpto >= 0);
                                         return;
                                     }
                                     else if (label == (outerInstance.termBytes[termOffset_i + i] & 0xFF))
@@ -1268,7 +1269,7 @@ namespace Lucene.Net.Codecs.Memory
                                             int nextState = runAutomaton.Step(states[stateUpto].state, label);
 
                                             // Automaton is required to accept startTerm:
-                                            Debug.Assert(nextState != -1);
+                                            Debugging.Assert(() => nextState != -1);
 
                                             stateUpto++;
                                             states[stateUpto].changeOrd = outerInstance.skips[skipOffset + skipUpto++];
@@ -1299,12 +1300,12 @@ namespace Lucene.Net.Codecs.Memory
                                             while (termOrd < outerInstance.terms.Length &&
                                                    outerInstance.Compare(termOrd, startTerm) <= 0)
                                             {
-                                                Debug.Assert(termOrd == startTermOrd ||
+                                                Debugging.Assert(() => termOrd == startTermOrd ||
                                                              outerInstance.skipOffsets[termOrd] ==
                                                              outerInstance.skipOffsets[termOrd + 1]);
                                                 termOrd++;
                                             }
-                                            Debug.Assert(termOrd - startTermOrd < outerInstance.minSkipCount);
+                                            Debugging.Assert(() => termOrd - startTermOrd < outerInstance.minSkipCount);
                                             termOrd--;
                                             stateUpto -= skipUpto;
                                             // if (DEBUG) {
@@ -1385,7 +1386,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (termOrd == 0 && outerInstance.termOffsets[1] == 0)
                     {
                         // Special-case empty string:
-                        Debug.Assert(stateUpto == 0);
+                        Debugging.Assert(() => stateUpto == 0);
                         // if (DEBUG) {
                         //   System.out.println("  visit empty string");
                         // }
@@ -1434,9 +1435,9 @@ namespace Lucene.Net.Codecs.Memory
                         //   System.out.println("  term=" + new BytesRef(termBytes, termOffset, termLength).utf8ToString() + " skips=" + Arrays.toString(skips));
                         // }
 
-                        Debug.Assert(termOrd < state.changeOrd);
+                        Debugging.Assert(() => termOrd < state.changeOrd);
 
-                        Debug.Assert(stateUpto <= termLength, "term.length=" + termLength + "; stateUpto=" + stateUpto);
+                        Debugging.Assert(() => stateUpto <= termLength, () => "term.length=" + termLength + "; stateUpto=" + stateUpto);
                         int label = outerInstance.termBytes[termOffset + stateUpto] & 0xFF;
 
                         while (label > state.transitionMax)
@@ -1455,7 +1456,7 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 else
                                 {
-                                    Debug.Assert(state.changeOrd > termOrd);
+                                    Debugging.Assert(() => state.changeOrd > termOrd);
                                     // if (DEBUG) {
                                     //   System.out.println("  jumpend " + (state.changeOrd - termOrd));
                                     // }
@@ -1466,14 +1467,14 @@ namespace Lucene.Net.Codecs.Memory
                                 }
                                 goto nextTermContinue;
                             }
-                            Debug.Assert(state.transitionUpto < state.transitions.Length,
-                                " state.transitionUpto=" + state.transitionUpto + " vs " + state.transitions.Length);
+                            Debugging.Assert(() => state.transitionUpto < state.transitions.Length,
+                                () => " state.transitionUpto=" + state.transitionUpto + " vs " + state.transitions.Length);
                             state.transitionMin = state.transitions[state.transitionUpto].Min;
                             state.transitionMax = state.transitions[state.transitionUpto].Max;
-                            Debug.Assert(state.transitionMin >= 0);
-                            Debug.Assert(state.transitionMin <= 255);
-                            Debug.Assert(state.transitionMax >= 0);
-                            Debug.Assert(state.transitionMax <= 255);
+                            Debugging.Assert(() => state.transitionMin >= 0);
+                            Debugging.Assert(() => state.transitionMin <= 255);
+                            Debugging.Assert(() => state.transitionMax >= 0);
+                            Debugging.Assert(() => state.transitionMax <= 255);
                         }
 
                         int targetLabel = state.transitionMin;
@@ -1602,7 +1603,7 @@ namespace Lucene.Net.Codecs.Memory
                             if (compiledAutomaton.CommonSuffixRef != null)
                             {
                                 //System.out.println("suffix " + compiledAutomaton.commonSuffixRef.utf8ToString());
-                                Debug.Assert(compiledAutomaton.CommonSuffixRef.Offset == 0);
+                                Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
                                 if (termLength < compiledAutomaton.CommonSuffixRef.Length)
                                 {
                                     termOrd++;
@@ -2001,7 +2002,7 @@ namespace Lucene.Net.Codecs.Memory
                     if (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        Debug.Assert(freq > 0);
+                        Debugging.Assert(() => freq > 0);
                         return postings[upto];
                     }
                 }
@@ -2010,7 +2011,7 @@ namespace Lucene.Net.Codecs.Memory
                     while (upto < postings.Length)
                     {
                         freq = postings[upto + 1];
-                        Debug.Assert(freq > 0);
+                        Debugging.Assert(() => freq > 0);
                         if (liveDocs.Get(postings[upto]))
                         {
                             return postings[upto];
@@ -2185,7 +2186,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public override int NextPosition()
             {
-                Debug.Assert(skipPositions > 0);
+                Debugging.Assert(() => skipPositions > 0);
                 skipPositions--;
 
                 int pos = postings[upto++];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
index 2075848..55d733e 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTOrdTermsReader.cs
@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using JCG = J2N.Collections.Generic;
 using BitSet = Lucene.Net.Util.OpenBitSet;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Codecs.Memory
 {
@@ -165,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -217,7 +218,7 @@ namespace Lucene.Net.Codecs.Memory
                 this.longsSize = longsSize;
                 this.index = index;
 
-                Debug.Assert((numTerms & (~0xffffffffL)) == 0);
+                Debugging.Assert(() => (numTerms & (~0xffffffffL)) == 0);
                 int numBlocks = (int)(numTerms + INTERVAL - 1) / INTERVAL;
                 this.numSkipInfo = longsSize + 3;
                 this.skipInfo = new long[numBlocks * numSkipInfo];
@@ -499,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         var status = SeekCeil(term);
-                        Debug.Assert(status == SeekStatus.FOUND); // must positioned on valid term
+                        Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -630,7 +631,7 @@ namespace Lucene.Net.Codecs.Memory
                 internal override void DecodeStats()
                 {
                     var arc = TopFrame().arc;
-                    Debug.Assert(arc.NextFinalOutput == fstOutputs.NoOutput);
+                    Debugging.Assert(() => arc.NextFinalOutput == fstOutputs.NoOutput);
                     ord = arc.Output.Value;
                     base.DecodeStats();
                 }
@@ -698,7 +699,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        Debug.Assert(IsValid(frame)); // target must be fetched from automaton
+                        Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
@@ -836,7 +837,7 @@ namespace Lucene.Net.Codecs.Memory
                     arc.Output = fstOutputs.Add(TopFrame().arc.Output, arc.Output);
                     term = Grow(arc.Label);
                     level++;
-                    Debug.Assert(frame == stack[level]);
+                    Debugging.Assert(() => frame == stack[level]);
                 }
 
                 private Frame PopFrame()
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
index 37a64b4..93c61d1 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermOutputs.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using System.Diagnostics;
 
 namespace Lucene.Net.Codecs.Memory
@@ -127,7 +128,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t1, NO_OUTPUT) || Equals(t2, NO_OUTPUT))
                 return NO_OUTPUT;
             
-            Debug.Assert(t1.longs.Length == t2.longs.Length);
+            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             long[] min = t1.longs, max = t2.longs;
             int pos = 0;
@@ -182,7 +183,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            Debug.Assert(t1.longs.Length == t2.longs.Length);
+            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             int pos = 0;
             long diff = 0;
@@ -219,7 +220,7 @@ namespace Lucene.Net.Codecs.Memory
             if (Equals(t2, NO_OUTPUT))
                 return t1;
             
-            Debug.Assert(t1.longs.Length == t2.longs.Length);
+            Debugging.Assert(() => t1.longs.Length == t2.longs.Length);
 
             var pos = 0;
             var accum = new long[_longsSize];
diff --git a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
index c3ced65..4eb4a32 100644
--- a/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
+++ b/src/Lucene.Net.Codecs/Memory/FSTTermsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
@@ -165,7 +166,7 @@ namespace Lucene.Net.Codecs.Memory
 
         public override Terms GetTerms(string field)
         {
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
             TermsReader result;
             fields.TryGetValue(field, out result);
             return result;
@@ -368,7 +369,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         seekPending = false;
                         SeekStatus status = SeekCeil(term);
-                        Debug.Assert(status == SeekStatus.FOUND); // must positioned on valid term
+                        Debugging.Assert(() => status == SeekStatus.FOUND); // must positioned on valid term
                     }
                     UpdateEnum(fstEnum.Next());
                     return term;
@@ -499,7 +500,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 internal override void DecodeMetaData()
                 {
-                    Debug.Assert(term != null);
+                    Debugging.Assert(() => term != null);
                     if (!decoded)
                     {
                         if (meta.bytes != null)
@@ -610,7 +611,7 @@ namespace Lucene.Net.Codecs.Memory
                         {
                             break;
                         }
-                        Debug.Assert(IsValid(frame)); // target must be fetched from automaton
+                        Debugging.Assert(() => IsValid(frame)); // target must be fetched from automaton
                         PushFrame(frame);
                         upto++;
                     }
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
index f21ecfa..b7c595c 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Util.Fst;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util.Fst;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -143,7 +144,7 @@ namespace Lucene.Net.Codecs.Memory
 
                     ++count;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
             }
 
             if (missing)
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
index 64c8e98..de1b5fa 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
@@ -1,4 +1,5 @@
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -674,7 +675,7 @@ namespace Lucene.Net.Codecs.Memory
                     {
                         var data = (IndexInput)this.data.Clone();
                         data.Seek(offset);
-                        Debug.Assert(length%8 == 0);
+                        Debugging.Assert(() => length % 8 == 0);
                         var bits = new long[(int) length >> 3];
                         for (var i = 0; i < bits.Length; i++)
                         {
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index 8e6ce5b..8df0e00 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
@@ -145,7 +146,7 @@ namespace Lucene.Net.Codecs.Memory
                 public override void StartDoc(int docID, int termDocFreq)
                 {
                     int delta = docID - lastDocID;
-                    Debug.Assert(docID == 0 || delta > 0);
+                    Debugging.Assert(() => docID == 0 || delta > 0);
                     lastDocID = docID;
                     docCount++;
 
@@ -160,7 +161,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         buffer.WriteVInt32(delta << 1);
-                        Debug.Assert(termDocFreq > 0);
+                        Debugging.Assert(() => termDocFreq > 0);
                         buffer.WriteVInt32(termDocFreq);
                     }
 
@@ -170,12 +171,12 @@ namespace Lucene.Net.Codecs.Memory
 
                 public override void AddPosition(int pos, BytesRef payload, int startOffset, int endOffset)
                 {
-                    Debug.Assert(payload == null || outerInstance.field.HasPayloads);
+                    Debugging.Assert(() => payload == null || outerInstance.field.HasPayloads);
 
                     //System.out.println("      addPos pos=" + pos + " payload=" + payload);
 
                     int delta = pos - lastPos;
-                    Debug.Assert(delta >= 0);
+                    Debugging.Assert(() => delta >= 0);
                     lastPos = pos;
 
                     int payloadLen = 0;
@@ -230,7 +231,7 @@ namespace Lucene.Net.Codecs.Memory
 
                 public virtual PostingsWriter Reset()
                 {
-                    Debug.Assert(buffer.GetFilePointer() == 0);
+                    Debugging.Assert(() => buffer.GetFilePointer() == 0);
                     lastDocID = 0;
                     docCount = 0;
                     lastPayloadLen = 0;
@@ -254,9 +255,9 @@ namespace Lucene.Net.Codecs.Memory
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debug.Assert(postingsWriter.docCount == stats.DocFreq);
+                Debugging.Assert(() => postingsWriter.docCount == stats.DocFreq);
 
-                Debug.Assert(buffer2.GetFilePointer() == 0);
+                Debugging.Assert(() => buffer2.GetFilePointer() == 0);
 
                 buffer2.WriteVInt32(stats.DocFreq);
                 if (field.IndexOptions != IndexOptions.DOCS_ONLY)
@@ -401,7 +402,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                Debug.Assert(numDocs > 0);
+                Debugging.Assert(() => numDocs > 0);
                 if (buffer.Length < bufferIn.Length)
                 {
                     buffer = ArrayUtil.Grow(buffer, bufferIn.Length);
@@ -445,7 +446,7 @@ namespace Lucene.Net.Codecs.Memory
                         else
                         {
                             freq = @in.ReadVInt32();
-                            Debug.Assert(freq > 0);
+                            Debugging.Assert(() => freq > 0);
                         }
 
                         if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS)
@@ -554,7 +555,7 @@ namespace Lucene.Net.Codecs.Memory
 
             public FSTDocsAndPositionsEnum Reset(BytesRef bufferIn, IBits liveDocs, int numDocs)
             {
-                Debug.Assert(numDocs > 0);
+                Debugging.Assert(() => numDocs > 0);
 
                 // System.out.println("D&P reset bytes this=" + this);
                 // for(int i=bufferIn.offset;i<bufferIn.length;i++) {
@@ -605,7 +606,7 @@ namespace Lucene.Net.Codecs.Memory
                     else
                     {
                         freq = @in.ReadVInt32();
-                        Debug.Assert(freq > 0);
+                        Debugging.Assert(() => freq > 0);
                     }
 
                     if (liveDocs == null || liveDocs.Get(accum))
@@ -654,7 +655,7 @@ namespace Lucene.Net.Codecs.Memory
             public override int NextPosition()
             {
                 //System.out.println("    nextPos storePayloads=" + storePayloads + " this=" + this);
-                Debug.Assert(posPending > 0);
+                Debugging.Assert(() => posPending > 0);
                 posPending--;
                 if (!storePayloads)
                 {
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
index 78d6db7..17ed5fb 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsFormat.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System.Diagnostics;
@@ -46,7 +47,7 @@ namespace Lucene.Net.Codecs.Pulsing
             int minBlockSize, int maxBlockSize) 
             : base()
         {
-            Debug.Assert(minBlockSize > 1);
+            Debugging.Assert(() => minBlockSize > 1);
 
             _freqCutoff = freqCutoff;
             _minBlockSize = minBlockSize;
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
index 77cccc3..d43a4f7 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsReader.cs
@@ -1,4 +1,5 @@
 using J2N.Runtime.CompilerServices;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -121,7 +122,7 @@ namespace Lucene.Net.Codecs.Pulsing
                 }
                 else
                 {
-                    Debug.Assert(WrappedTermState != null);
+                    Debugging.Assert(() => WrappedTermState != null);
                     clone.WrappedTermState = (BlockTermState)WrappedTermState.Clone();
                     clone.Absolute = Absolute;
 
@@ -171,7 +172,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var termState2 = (PulsingTermState) termState;
 
-            Debug.Assert(empty.Length == 0);
+            Debugging.Assert(() => empty.Length == 0);
 
             termState2.Absolute = termState2.Absolute || absolute;
             // if we have positions, its total TF, otherwise its computed based on docFreq.
@@ -339,7 +340,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                Debug.Assert(termState.PostingsSize != -1);
+                Debugging.Assert(() => termState.PostingsSize != -1);
 
                 // Must make a copy of termState's byte[] so that if
                 // app does TermsEnum.next(), this DocsEnum is not affected
@@ -481,7 +482,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public virtual PulsingDocsAndPositionsEnum Reset(IBits liveDocs, PulsingTermState termState)
             {
-                Debug.Assert(termState.PostingsSize != -1);
+                Debugging.Assert(() => termState.PostingsSize != -1);
 
                 if (_postingsBytes == null)
                 {
@@ -541,7 +542,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             public override int NextPosition()
             {
-                Debug.Assert(_posPending > 0);
+                Debugging.Assert(() => _posPending > 0);
 
                 _posPending--;
 
diff --git a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
index 38034f7..7179fd5 100644
--- a/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Pulsing/PulsingPostingsWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -149,7 +150,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartTerm()
         {
-            Debug.Assert(_pendingCount == 0);
+            Debugging.Assert(() => _pendingCount == 0);
         }
 
         // TODO: -- should we NOT reuse across fields?  would
@@ -174,7 +175,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
         public override void StartDoc(int docId, int termDocFreq)
         {
-            Debug.Assert(docId >= 0, "Got DocID=" + docId);
+            Debugging.Assert(() => docId >= 0, () => "Got DocID=" + docId);
 
             if (_pendingCount == _pending.Length)
             {
@@ -184,7 +185,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
             if (_pendingCount != -1)
             {
-                Debug.Assert(_pendingCount < _pending.Length);
+                Debugging.Assert(() => _pendingCount < _pending.Length);
                 _currentDoc = _pending[_pendingCount];
                 _currentDoc.docID = docId;
                 if (_indexOptions == IndexOptions.DOCS_ONLY)
@@ -266,7 +267,7 @@ namespace Lucene.Net.Codecs.Pulsing
         {
             var state2 = (PulsingTermState)state;
 
-            Debug.Assert(_pendingCount > 0 || _pendingCount == -1);
+            Debugging.Assert(() => _pendingCount > 0 || _pendingCount == -1);
 
             if (_pendingCount == -1)
             {
@@ -317,7 +318,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         for (var posIDX = 0; posIDX < doc.termFreq; posIDX++)
                         {
                             var pos = _pending[pendingIDX++];
-                            Debug.Assert(pos.docID == doc.docID);
+                            Debugging.Assert(() => pos.docID == doc.docID);
                             var posDelta = pos.pos - lastPos;
                             lastPos = pos.pos;
 
@@ -360,7 +361,7 @@ namespace Lucene.Net.Codecs.Pulsing
 
                             if (payloadLength > 0)
                             {
-                                Debug.Assert(_storePayloads);
+                                Debugging.Assert(() => _storePayloads);
                                 _buffer.WriteBytes(pos.payload.Bytes, 0, pos.payload.Length);
                             }
                         }
@@ -374,7 +375,7 @@ namespace Lucene.Net.Codecs.Pulsing
                         Position doc = _pending[posIdx];
                         int delta = doc.docID - lastDocId;
 
-                        Debug.Assert(doc.termFreq != 0);
+                        Debugging.Assert(() => doc.termFreq != 0);
 
                         if (doc.termFreq == 1)
                         {
@@ -410,7 +411,7 @@ namespace Lucene.Net.Codecs.Pulsing
             bool abs)
         {
             var _state = (PulsingTermState)state;
-            Debug.Assert(empty.Length == 0);
+            Debugging.Assert(() => empty.Length == 0);
             _absolute = _absolute || abs;
             if (_state.bytes == null)
             {
@@ -468,7 +469,7 @@ namespace Lucene.Net.Codecs.Pulsing
         /// </summary>
         private void Push()
         {
-            Debug.Assert(_pendingCount == _pending.Length);
+            Debugging.Assert(() => _pendingCount == _pending.Length);
 
             _wrappedPostingsWriter.StartTerm();
 
@@ -486,7 +487,7 @@ namespace Lucene.Net.Codecs.Pulsing
                     }
                     else if (doc.docID != pos.docID)
                     {
-                        Debug.Assert(pos.docID > doc.docID);
+                        Debugging.Assert(() => pos.docID > doc.docID);
                         _wrappedPostingsWriter.FinishDoc();
                         doc = pos;
                         _wrappedPostingsWriter.StartDoc(doc.docID, doc.termFreq);
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
index cc6b4b4..5943d16 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System.Diagnostics;
@@ -262,7 +263,7 @@ namespace Lucene.Net.Codecs.Sep
         public override DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState termState,
             IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags)
         {
-            Debug.Assert(fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            Debugging.Assert(() => fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
             SepTermState termState_ = (SepTermState)termState;
             SepDocsAndPositionsEnum postingsEnum;
             if (reuse == null || !(reuse is SepDocsAndPositionsEnum))
@@ -691,7 +692,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        Debug.Assert(payloadLength >= 0);
+                        Debugging.Assert(() => payloadLength >= 0);
                     }
                     pendingPosCount--;
                     position = 0;
@@ -706,7 +707,7 @@ namespace Lucene.Net.Codecs.Sep
                     {
                         // Payload length has changed
                         payloadLength = posReader.Next();
-                        Debug.Assert(payloadLength >= 0);
+                        Debugging.Assert(() => payloadLength >= 0);
                     }
                     position += (int)(((uint)code) >> 1);
                     pendingPayloadBytes += payloadLength;
@@ -718,7 +719,7 @@ namespace Lucene.Net.Codecs.Sep
                 }
 
                 pendingPosCount--;
-                Debug.Assert(pendingPosCount >= 0);
+                Debugging.Assert(() => pendingPosCount >= 0);
                 return position;
             }
 
@@ -740,7 +741,7 @@ namespace Lucene.Net.Codecs.Sep
                     return payload;
                 }
 
-                Debug.Assert(pendingPayloadBytes >= payloadLength);
+                Debugging.Assert(() => pendingPayloadBytes >= payloadLength);
 
                 if (pendingPayloadBytes > payloadLength)
                 {
diff --git a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
index a9b78fb..5f75ab4 100644
--- a/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepPostingsWriter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
@@ -261,10 +262,10 @@ namespace Lucene.Net.Codecs.Sep
         /// Add a new position &amp; payload. </summary>
         public override void AddPosition(int position, BytesRef payload, int startOffset, int endOffset)
         {
-            Debug.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
 
             int delta = position - lastPosition;
-            Debug.Assert(delta >= 0, "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
+            Debugging.Assert(() => delta >= 0, () => "position=" + position + " lastPosition=" + lastPosition);            // not quite right (if pos=0 is repeated twice we don't catch it)
             lastPosition = position;
 
             if (storePayloads)
@@ -316,8 +317,8 @@ namespace Lucene.Net.Codecs.Sep
         {
             SepTermState state_ = (SepTermState)state;
             // TODO: -- wasteful we are counting this in two places?
-            Debug.Assert(state_.DocFreq > 0);
-            Debug.Assert(state_.DocFreq == df);
+            Debugging.Assert(() => state_.DocFreq > 0);
+            Debugging.Assert(() => state_.DocFreq == df);
 
             state_.DocIndex = docOut.GetIndex();
             state_.DocIndex.CopyFrom(docIndex, false);
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
index d774121..54528de 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using System.Diagnostics;
@@ -194,7 +195,7 @@ namespace Lucene.Net.Codecs.Sep
         protected override int ReadSkipData(int level, IndexInput skipStream)
         {
             int delta;
-            Debug.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
+            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !currentFieldStoresPayloads);
             if (currentFieldStoresPayloads)
             {
                 // the current field stores payloads.
diff --git a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
index 96a984e..3cd61c1 100644
--- a/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
+++ b/src/Lucene.Net.Codecs/Sep/SepSkipListWriter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using System.Diagnostics;
@@ -177,7 +178,7 @@ namespace Lucene.Net.Codecs.Sep
             //         current payload length equals the length at the previous
             //         skip point
 
-            Debug.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
+            Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS || !curStorePayloads);
 
             if (curStorePayloads)
             {
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
index 586a5bb..1b53e2d 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
@@ -75,14 +76,14 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     break;
                 }
-                Debug.Assert(StartsWith(SimpleTextDocValuesWriter.FIELD), scratch.Utf8ToString());
+                Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.FIELD), () => scratch.Utf8ToString());
                 var fieldName = StripPrefix(SimpleTextDocValuesWriter.FIELD);
                 var field = new OneField();
                 
                 fields[fieldName] = field;
 
                 ReadLine();
-                Debug.Assert(StartsWith(SimpleTextDocValuesWriter.TYPE), scratch.Utf8ToString());
+                Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.TYPE), () => scratch.Utf8ToString());
 
                 var dvType =
                     (DocValuesType)
@@ -91,11 +92,11 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (dvType == DocValuesType.NUMERIC)
                 {
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.MINVALUE),
-                        "got " + scratch.Utf8ToString() + " field=" + fieldName + " ext=" + ext);
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MINVALUE),
+                        () => "got " + scratch.Utf8ToString() + " field=" + fieldName + " ext=" + ext);
                     field.MinValue = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.MINVALUE), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (1 + field.Pattern.Length + 2)*maxDoc);
@@ -103,10 +104,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.BINARY)
                 {
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength + 2)*maxDoc);
@@ -114,16 +115,16 @@ namespace Lucene.Net.Codecs.SimpleText
                 else if (dvType == DocValuesType.SORTED || dvType == DocValuesType.SORTED_SET)
                 {
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.NUMVALUES));
                     field.NumValues = Convert.ToInt64(StripPrefix(SimpleTextDocValuesWriter.NUMVALUES), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.MAXLENGTH));
                     field.MaxLength = Convert.ToInt32(StripPrefix(SimpleTextDocValuesWriter.MAXLENGTH), CultureInfo.InvariantCulture);
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.PATTERN));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.PATTERN));
                     field.Pattern = StripPrefix(SimpleTextDocValuesWriter.PATTERN);
                     ReadLine();
-                    Debug.Assert(StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
+                    Debugging.Assert(() => StartsWith(SimpleTextDocValuesWriter.ORDPATTERN));
                     field.OrdPattern = StripPrefix(SimpleTextDocValuesWriter.ORDPATTERN);
                     field.DataStartFilePointer = data.GetFilePointer();
                     data.Seek(data.GetFilePointer() + (9 + field.Pattern.Length + field.MaxLength)*field.NumValues +
@@ -137,16 +138,16 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // We should only be called from above if at least one
             // field has DVs:
-            Debug.Assert(fields.Count > 0);
+            Debugging.Assert(() => fields.Count > 0);
         }
 
         public override NumericDocValues GetNumeric(FieldInfo fieldInfo)
         {
             var field = fields[fieldInfo.Name];
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
 
             // SegmentCoreReaders already verifies this field is valid:
-            Debug.Assert(field != null, "field=" + fieldInfo.Name + " fields=" + fields);
+            Debugging.Assert(() => field != null, () => "field=" + fieldInfo.Name + " fields=" + fields);
 
             var @in = (IndexInput)data.Clone();
             var scratch = new BytesRef();
@@ -242,7 +243,7 @@ namespace Lucene.Net.Codecs.SimpleText
         public override BinaryDocValues GetBinary(FieldInfo fieldInfo)
         {
             var field = fields[fieldInfo.Name];
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -276,7 +277,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * docId);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -333,7 +334,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 {
                     _input.Seek(_field.DataStartFilePointer + (9 + _field.Pattern.Length + _field.MaxLength + 2) * index);
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH));
                     int len;
                     try
                     {
@@ -366,7 +367,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var field = fields[fieldInfo.Name];
 
             // SegmentCoreReaders already verifies this field is valid:
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
             var input = (IndexInput)data.Clone();
             var scratch = new BytesRef();
 
@@ -435,8 +436,8 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
-                        "got " + _scratch.Utf8ToString() + " in=" + _input);
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                        () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
                     {
@@ -471,7 +472,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             // SegmentCoreReaders already verifies this field is
             // valid:
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
 
             var input = (IndexInput) data.Clone();
             var scratch = new BytesRef();
@@ -540,8 +541,8 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     _input.Seek(_field.DataStartFilePointer + ord * (9 + _field.Pattern.Length + _field.MaxLength));
                     SimpleTextUtil.ReadLine(_input, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
-                        "got " + _scratch.Utf8ToString() + " in=" + _input);
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextDocValuesWriter.LENGTH),
+                        () => "got " + _scratch.Utf8ToString() + " in=" + _input);
                     int len;
                     try
                     {
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
index 1c544ea..856baa2 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesWriter.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -68,15 +69,15 @@ namespace Lucene.Net.Codecs.SimpleText
         /// </summary>
         private bool FieldSeen(string field)
         {
-            Debug.Assert(!_fieldsSeen.Contains(field), "field \"" + field + "\" was added more than once during flush");
+            Debugging.Assert(() => !_fieldsSeen.Contains(field), () => "field \"" + field + "\" was added more than once during flush");
             _fieldsSeen.Add(field);
             return true;
         }
 
         public override void AddNumericField(FieldInfo field, IEnumerable<long?> values)
         {
-            Debug.Assert(FieldSeen(field.Name));
-            Debug.Assert(field.DocValuesType == DocValuesType.NUMERIC ||
+            Debugging.Assert(() => FieldSeen(field.Name));
+            Debugging.Assert(() => field.DocValuesType == DocValuesType.NUMERIC ||
                          field.NormType == DocValuesType.NUMERIC);
             WriteFieldEntry(field, DocValuesType.NUMERIC);
 
@@ -117,26 +118,26 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 long value = n.GetValueOrDefault();
 
-                Debug.Assert(value >= minValue);
+                Debugging.Assert(() => value >= minValue);
 
                 var delta = (decimal)value - (decimal)minValue; // LUCENENET specific - use decimal rather than BigInteger
                 string s = delta.ToString(patternString, CultureInfo.InvariantCulture);
-                Debug.Assert(s.Length == patternString.Length);
+                Debugging.Assert(() => s.Length == patternString.Length);
                 SimpleTextUtil.Write(data, s, scratch);
                 SimpleTextUtil.WriteNewline(data);
                 SimpleTextUtil.Write(data, n == null ? "F" : "T", scratch);
                 SimpleTextUtil.WriteNewline(data);
                 numDocsWritten++;
-                Debug.Assert(numDocsWritten <= numDocs);
+                Debugging.Assert(() => numDocsWritten <= numDocs);
             }
 
-            Debug.Assert(numDocs == numDocsWritten, "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
+            Debugging.Assert(() => numDocs == numDocsWritten, () => "numDocs=" + numDocs + " numDocsWritten=" + numDocsWritten);
         }
 
         public override void AddBinaryField(FieldInfo field, IEnumerable<BytesRef> values)
         {
-            Debug.Assert(FieldSeen(field.Name));
-            Debug.Assert(field.DocValuesType == DocValuesType.BINARY);
+            Debugging.Assert(() => FieldSeen(field.Name));
+            Debugging.Assert(() => field.DocValuesType == DocValuesType.BINARY);
 
             var maxLength = 0;
             foreach (var value in values)
@@ -191,13 +192,13 @@ namespace Lucene.Net.Codecs.SimpleText
                 numDocsWritten++;
             }
 
-            Debug.Assert(numDocs == numDocsWritten);
+            Debugging.Assert(() => numDocs == numDocsWritten);
         }
 
         public override void AddSortedField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<long?> docToOrd)
         {
-            Debug.Assert(FieldSeen(field.Name));
-            Debug.Assert(field.DocValuesType == DocValuesType.SORTED);
+            Debugging.Assert(() => FieldSeen(field.Name));
+            Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED);
             WriteFieldEntry(field, DocValuesType.SORTED);
 
             int valueCount = 0;
@@ -267,10 +268,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                Debug.Assert(valuesSeen <= valueCount);
+                Debugging.Assert(() => valuesSeen <= valueCount);
             }
 
-            Debug.Assert(valuesSeen == valueCount);
+            Debugging.Assert(() => valuesSeen == valueCount);
 
             foreach (var ord in docToOrd)
             {
@@ -282,8 +283,8 @@ namespace Lucene.Net.Codecs.SimpleText
         public override void AddSortedSetField(FieldInfo field, IEnumerable<BytesRef> values,
             IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
         {
-            Debug.Assert(FieldSeen(field.Name));
-            Debug.Assert(field.DocValuesType == DocValuesType.SORTED_SET);
+            Debugging.Assert(() => FieldSeen(field.Name));
+            Debugging.Assert(() => field.DocValuesType == DocValuesType.SORTED_SET);
             WriteFieldEntry(field, DocValuesType.SORTED_SET);
 
             long valueCount = 0;
@@ -374,10 +375,10 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
                 SimpleTextUtil.WriteNewline(data);
                 valuesSeen++;
-                Debug.Assert(valuesSeen <= valueCount);
+                Debugging.Assert(() => valuesSeen <= valueCount);
             }
 
-            Debug.Assert(valuesSeen == valueCount);
+            Debugging.Assert(() => valuesSeen == valueCount);
 
             using (var ordStream = ords.GetEnumerator())
             {
@@ -425,7 +426,7 @@ namespace Lucene.Net.Codecs.SimpleText
             var success = false;
             try
             {
-                Debug.Assert(_fieldsSeen.Count > 0);
+                Debugging.Assert(() => _fieldsSeen.Count > 0);
                 // java : sheisty to do this here?
                 SimpleTextUtil.Write(data, END);
                 SimpleTextUtil.WriteNewline(data);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
index ea658b0..9c50ef3 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosReader.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
@@ -56,29 +57,29 @@ namespace Lucene.Net.Codecs.SimpleText
             {
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMFIELDS));
                 var size = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMFIELDS.Length, scratch), CultureInfo.InvariantCulture);
                 var infos = new FieldInfo[size];
 
                 for (var i = 0; i < size; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NAME));
                     string name = ReadString(SimpleTextFieldInfosWriter.NAME.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUMBER));
                     int fieldNumber = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUMBER.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ISINDEXED));
                     bool isIndexed = Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.ISINDEXED.Length, scratch), CultureInfo.InvariantCulture);
 
                     IndexOptions indexOptions;
                     if (isIndexed)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
+                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.INDEXOPTIONS));
                         indexOptions = (IndexOptions)Enum.Parse(typeof(IndexOptions), ReadString(SimpleTextFieldInfosWriter.INDEXOPTIONS.Length,
                                 scratch));
                     }
@@ -88,46 +89,46 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.STORETV));
                     bool storeTermVector =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.STORETV.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.PAYLOADS));
                     bool storePayloads =
                         Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.PAYLOADS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS));
                     bool omitNorms = !Convert.ToBoolean(ReadString(SimpleTextFieldInfosWriter.NORMS.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NORMS_TYPE));
                     string nrmType = ReadString(SimpleTextFieldInfosWriter.NORMS_TYPE.Length, scratch);
                     Index.DocValuesType normsType = DocValuesType(nrmType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES));
                     string dvType = ReadString(SimpleTextFieldInfosWriter.DOCVALUES.Length, scratch);
                     Index.DocValuesType docValuesType = DocValuesType(dvType);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.DOCVALUES_GEN));
                     long dvGen = Convert.ToInt64(ReadString(SimpleTextFieldInfosWriter.DOCVALUES_GEN.Length, scratch), CultureInfo.InvariantCulture);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.NUM_ATTS));
                     int numAtts = Convert.ToInt32(ReadString(SimpleTextFieldInfosWriter.NUM_ATTS.Length, scratch), CultureInfo.InvariantCulture);
                     IDictionary<string, string> atts = new Dictionary<string, string>();
 
                     for (int j = 0; j < numAtts; j++)
                     {
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
+                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_KEY));
                         string key = ReadString(SimpleTextFieldInfosWriter.ATT_KEY.Length, scratch);
 
                         SimpleTextUtil.ReadLine(input, scratch);
-                        Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
+                        Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextFieldInfosWriter.ATT_VALUE));
                         string value = ReadString(SimpleTextFieldInfosWriter.ATT_VALUE.Length, scratch);
                         atts[key] = value;
                     }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
index 82735dc..02b8cb2 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldInfosWriter.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using Lucene.Net.Diagnostics;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 
@@ -91,7 +92,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                     if (fi.IsIndexed)
                     {
-                        Debug.Assert(fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        Debugging.Assert(() => fi.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         SimpleTextUtil.Write(output, INDEXOPTIONS);
                         SimpleTextUtil.Write(output, 
                             fi.IndexOptions != IndexOptions.NONE ? fi.IndexOptions.ToString() : string.Empty, 
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
index 33b8bb4..04f6522 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
@@ -313,8 +314,8 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     else
                     {
-                        Debug.Assert(
-                            StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
+                        Debugging.Assert(
+                            () => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                             // LUCENENET TODO: This assert fails sometimes, which in turns causes _scratch.Utf8ToString() to throw an index out of range exception
                             StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END) /*, "scratch=" + _scratch.Utf8ToString()*/);
 
@@ -444,7 +445,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     }
                     else
                     {
-                        Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
+                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.TERM) || StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.FIELD) ||
                                      StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END));
 
                         if (!first && (_liveDocs == null || _liveDocs.Get(_docId)))
@@ -470,7 +471,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readPositions)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), "got line=" + _scratch.Utf8ToString());
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.POS), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.POS.Length, _scratch.Length - SimpleTextFieldsWriter.POS.Length,
                         _scratchUtf162);
                     pos = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
@@ -483,12 +484,12 @@ namespace Lucene.Net.Codecs.SimpleText
                 if (_readOffsets)
                 {
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), "got line=" + _scratch.Utf8ToString());
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.START_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.START_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.START_OFFSET.Length, _scratchUtf162);
                     _startOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
                     SimpleTextUtil.ReadLine(_in, _scratch);
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), "got line=" + _scratch.Utf8ToString());
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextFieldsWriter.END_OFFSET), () => "got line=" + _scratch.Utf8ToString());
                     UnicodeUtil.UTF8toUTF16(_scratch.Bytes, _scratch.Offset + SimpleTextFieldsWriter.END_OFFSET.Length,
                         _scratch.Length - SimpleTextFieldsWriter.END_OFFSET.Length, _scratchUtf162);
                     _endOffset = ArrayUtil.ParseInt32(_scratchUtf162.Chars, 0, _scratchUtf162.Length);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
index 6e67e7c..91562fc 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextFieldsWriter.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -162,9 +163,9 @@ namespace Lucene.Net.Codecs.SimpleText
 
                 if (_writeOffsets)
                 {
-                    Debug.Assert(endOffset >= startOffset);
-                    Debug.Assert(startOffset >= _lastStartOffset,
-                        "startOffset=" + startOffset + " lastStartOffset=" + _lastStartOffset);
+                    Debugging.Assert(() => endOffset >= startOffset);
+                    Debugging.Assert(() => startOffset >= _lastStartOffset,
+                        () => "startOffset=" + startOffset + " lastStartOffset=" + _lastStartOffset);
                     _lastStartOffset = startOffset;
                     _outerInstance.Write(START_OFFSET);
                     _outerInstance.Write(Convert.ToString(startOffset, CultureInfo.InvariantCulture));
@@ -176,7 +177,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
                 if (payload != null && payload.Length > 0)
                 {
-                    Debug.Assert(payload.Length != 0);
+                    Debugging.Assert(() => payload.Length != 0);
                     _outerInstance.Write(PAYLOAD);
                     _outerInstance.Write(payload);
                     _outerInstance.Newline();
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
index 8df76e5..b7245f7 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextLiveDocsFormat.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -66,7 +67,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override IBits ReadLiveDocs(Directory dir, SegmentCommitInfo info, IOContext context)
         {
-            Debug.Assert(info.HasDeletions);
+            Debugging.Assert(() => info.HasDeletions);
             var scratch = new BytesRef();
             var scratchUtf16 = new CharsRef();
 
@@ -79,7 +80,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 input = dir.OpenChecksumInput(fileName, context);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SIZE));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SIZE));
                 var size = ParseInt32At(scratch, SIZE.Length, scratchUtf16);
 
                 var bits = new BitSet(size);
@@ -87,7 +88,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 SimpleTextUtil.ReadLine(input, scratch);
                 while (!scratch.Equals(END))
                 {
-                    Debug.Assert(StringHelper.StartsWith(scratch, DOC));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, DOC));
                     var docid = ParseInt32At(scratch, DOC.Length, scratchUtf16);
                     bits.Set(docid);
                     SimpleTextUtil.ReadLine(input, scratch);
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
index aa44774..8be96c1 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoReader.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -52,43 +53,43 @@ namespace Lucene.Net.Codecs.SimpleText
             try
             {
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_VERSION));
                 string version = ReadString(SimpleTextSegmentInfoWriter.SI_VERSION.Length, scratch);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DOCCOUNT));
                 int docCount = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_DOCCOUNT.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_USECOMPOUND));
                 bool isCompoundFile = Convert.ToBoolean(ReadString(SimpleTextSegmentInfoWriter.SI_USECOMPOUND.Length, scratch), CultureInfo.InvariantCulture);
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_DIAG));
                 int numDiag = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_DIAG.Length, scratch), CultureInfo.InvariantCulture);
                 IDictionary<string, string> diagnostics = new Dictionary<string, string>();
 
                 for (int i = 0; i < numDiag; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_KEY));
                     string key = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_KEY.Length, scratch);
 
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_DIAG_VALUE));
                     string value = ReadString(SimpleTextSegmentInfoWriter.SI_DIAG_VALUE.Length, scratch);
                     diagnostics[key] = value;
                 }
 
                 SimpleTextUtil.ReadLine(input, scratch);
-                Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
+                Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_NUM_FILES));
                 int numFiles = Convert.ToInt32(ReadString(SimpleTextSegmentInfoWriter.SI_NUM_FILES.Length, scratch), CultureInfo.InvariantCulture);
                 var files = new JCG.HashSet<string>();
 
                 for (int i = 0; i < numFiles; i++)
                 {
                     SimpleTextUtil.ReadLine(input, scratch);
-                    Debug.Assert(StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
+                    Debugging.Assert(() => StringHelper.StartsWith(scratch, SimpleTextSegmentInfoWriter.SI_FILE));
                     string fileName = ReadString(SimpleTextSegmentInfoWriter.SI_FILE.Length, scratch);
                     files.Add(fileName);
                 }
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
index 2a113a6..ac3e8d7 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextStoredFieldsReader.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Diagnostics;
 using System.Globalization;
 using System.Reflection;
@@ -112,26 +113,26 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            Debug.Assert(upto == _offsets.Length);
+            Debugging.Assert(() => upto == _offsets.Length);
         }
 
         public override void VisitDocument(int n, StoredFieldVisitor visitor)
         {
             _input.Seek(_offsets[n]);
             ReadLine();
-            Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
+            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NUM));
             var numFields = ParseInt32At(SimpleTextStoredFieldsWriter.NUM.Length);
 
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.FIELD));
                 int fieldNumber = ParseInt32At(SimpleTextStoredFieldsWriter.FIELD.Length);
                 FieldInfo fieldInfo = _fieldInfos.FieldInfo(fieldNumber);
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.NAME));
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.TYPE));
 
                 BytesRef type;
                 if (EqualsAt(SimpleTextStoredFieldsWriter.TYPE_STRING, _scratch, SimpleTextStoredFieldsWriter.TYPE.Length))
@@ -170,7 +171,7 @@ namespace Lucene.Net.Codecs.SimpleText
                         break;
                     case StoredFieldVisitor.Status.NO:
                         ReadLine();
-                        Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
                         break;
                     case StoredFieldVisitor.Status.STOP:
                         return;
@@ -181,7 +182,7 @@ namespace Lucene.Net.Codecs.SimpleText
         private void ReadField(BytesRef type, FieldInfo fieldInfo, StoredFieldVisitor visitor)
         {
             ReadLine();
-            Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
+            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextStoredFieldsWriter.VALUE));
             if (Equals(type, SimpleTextStoredFieldsWriter.TYPE_STRING))
             {
                 visitor.StringField(fieldInfo,
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
index 1fe2252..778219e 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -108,7 +109,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 }
             }
             SimpleTextUtil.CheckFooter(input);
-            Debug.Assert(upto == _offsets.Length);
+            Debugging.Assert(() => upto == _offsets.Length);
         }
 
         public override Fields Get(int doc)
@@ -118,7 +119,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             _input.Seek(_offsets[doc]);
             ReadLine();
-            Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
+            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.NUMFIELDS));
             var numFields = ParseInt32At(SimpleTextTermVectorsWriter.NUMFIELDS.Length);
             if (numFields == 0)
             {
@@ -127,28 +128,28 @@ namespace Lucene.Net.Codecs.SimpleText
             for (var i = 0; i < numFields; i++)
             {
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELD));
                 // skip fieldNumber:
                 ParseInt32At(SimpleTextTermVectorsWriter.FIELD.Length);
 
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDNAME));
                 var fieldName = ReadString(SimpleTextTermVectorsWriter.FIELDNAME.Length, _scratch);
 
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPOSITIONS));
                 var positions = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPOSITIONS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDOFFSETS));
                 var offsets = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDOFFSETS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDPAYLOADS));
                 var payloads = Convert.ToBoolean(ReadString(SimpleTextTermVectorsWriter.FIELDPAYLOADS.Length, _scratch), CultureInfo.InvariantCulture);
 
                 ReadLine();
-                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
+                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.FIELDTERMCOUNT));
                 var termCount = ParseInt32At(SimpleTextTermVectorsWriter.FIELDTERMCOUNT.Length);
 
                 var terms = new SimpleTVTerms(offsets, positions, payloads);
@@ -157,7 +158,7 @@ namespace Lucene.Net.Codecs.SimpleText
                 for (var j = 0; j < termCount; j++)
                 {
                     ReadLine();
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMTEXT));
                     var term = new BytesRef();
                     var termLength = _scratch.Length - SimpleTextTermVectorsWriter.TERMTEXT.Length;
                     term.Grow(termLength);
@@ -168,7 +169,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     terms.terms.Add(term, postings);
 
                     ReadLine();
-                    Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
+                    Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.TERMFREQ));
                     postings.freq = ParseInt32At(SimpleTextTermVectorsWriter.TERMFREQ.Length);
 
                     if (!positions && !offsets) continue;
@@ -193,12 +194,12 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (positions)
                         {
                             ReadLine();
-                            Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
+                            Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.POSITION));
                             postings.positions[k] = ParseInt32At(SimpleTextTermVectorsWriter.POSITION.Length);
                             if (payloads)
                             {
                                 ReadLine();
-                                Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
+                                Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.PAYLOAD));
                                 if (_scratch.Length - SimpleTextTermVectorsWriter.PAYLOAD.Length == 0)
                                 {
                                     postings.payloads[k] = null;
@@ -216,11 +217,11 @@ namespace Lucene.Net.Codecs.SimpleText
                         if (!offsets) continue;
 
                         ReadLine();
-                        Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
+                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.STARTOFFSET));
                         postings.startOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.STARTOFFSET.Length);
 
                         ReadLine();
-                        Debug.Assert(StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
+                        Debugging.Assert(() => StringHelper.StartsWith(_scratch, SimpleTextTermVectorsWriter.ENDOFFSET));
                         postings.endOffsets[k] = ParseInt32At(SimpleTextTermVectorsWriter.ENDOFFSET.Length);
                     }
                 }
@@ -443,7 +444,7 @@ namespace Lucene.Net.Codecs.SimpleText
             {
                 get
                 {
-                    Debug.Assert(_freqRenamed != -1);
+                    Debugging.Assert(() => _freqRenamed != -1);
                     return _freqRenamed;
                 }
             }
@@ -494,7 +495,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     if (_positions != null)
                         return _positions.Length;
 
-                    Debug.Assert(_startOffsets != null);
+                    Debugging.Assert(() => _startOffsets != null);
                     return _startOffsets.Length;
                 }
             }
@@ -539,7 +540,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
             public override int NextPosition()
             {
-                //Debug.Assert((_positions != null && _nextPos < _positions.Length) ||
+                //Debugging.Assert((_positions != null && _nextPos < _positions.Length) ||
                 //             _startOffsets != null && _nextPos < _startOffsets.Length);
 
                 // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
index 8ea3c91..011029e 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextTermVectorsWriter.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -142,7 +143,7 @@ namespace Lucene.Net.Codecs.SimpleText
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            Debug.Assert(_positions || _offsets);
+            Debugging.Assert(() => _positions || _offsets);
 
             if (_positions)
             {
@@ -155,7 +156,7 @@ namespace Lucene.Net.Codecs.SimpleText
                     Write(PAYLOAD);
                     if (payload != null)
                     {
-                        Debug.Assert(payload.Length > 0);
+                        Debugging.Assert(() => payload.Length > 0);
                         Write(payload);
                     }
                     NewLine();
diff --git a/src/Lucene.Net.Expressions/ExpressionComparator.cs b/src/Lucene.Net.Expressions/ExpressionComparator.cs
index 96483d7..e187adf 100644
--- a/src/Lucene.Net.Expressions/ExpressionComparator.cs
+++ b/src/Lucene.Net.Expressions/ExpressionComparator.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Queries.Function;
 using Lucene.Net.Search;
@@ -48,11 +49,11 @@ namespace Lucene.Net.Expressions
             base.SetScorer(scorer);
             // TODO: might be cleaner to lazy-init 'source' and set scorer after?
 
-            Debug.Assert(readerContext != null);
+            Debugging.Assert(() => readerContext != null);
             try
             {
                 var context = new Dictionary<string, object>();
-                Debug.Assert(scorer != null);
+                Debugging.Assert(() => scorer != null);
                 context["scorer"] = scorer;
                 scores = source.GetValues(context, readerContext);
             }
diff --git a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
index 8f66680..dd1b052 100644
--- a/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
+++ b/src/Lucene.Net.Expressions/ScoreFunctionValues.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Queries.Function;
 using Lucene.Net.Queries.Function.DocValues;
 using Lucene.Net.Search;
@@ -42,7 +43,7 @@ namespace Lucene.Net.Expressions
         {
             try
             {
-                Debug.Assert(document == scorer.DocID);
+                Debugging.Assert(() => document == scorer.DocID);
                 return scorer.GetScore();
             }
             catch (IOException exception)
diff --git a/src/Lucene.Net.Facet/DrillDownQuery.cs b/src/Lucene.Net.Facet/DrillDownQuery.cs
index d7f472c..65e9c52 100644
--- a/src/Lucene.Net.Facet/DrillDownQuery.cs
+++ b/src/Lucene.Net.Facet/DrillDownQuery.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -85,7 +86,7 @@ namespace Lucene.Net.Facet
             {
                 throw new ArgumentException("cannot apply filter unless baseQuery isn't null; pass ConstantScoreQuery instead");
             }
-            Debug.Assert(clauses.Length == 1 + other.drillDownDims.Count, clauses.Length + " vs " + (1 + other.drillDownDims.Count));
+            Debugging.Assert(() => clauses.Length == 1 + other.drillDownDims.Count, () => clauses.Length + " vs " + (1 + other.drillDownDims.Count));
             drillDownDims.PutAll(other.drillDownDims);
             query.Add(new FilteredQuery(clauses[0].Query, filter), Occur.MUST);
             for (int i = 1; i < clauses.Length; i++)
diff --git a/src/Lucene.Net.Facet/DrillSideways.cs b/src/Lucene.Net.Facet/DrillSideways.cs
index 9939ada..65d4c10 100644
--- a/src/Lucene.Net.Facet/DrillSideways.cs
+++ b/src/Lucene.Net.Facet/DrillSideways.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Facet.SortedSet;
 using Lucene.Net.Facet.Taxonomy;
 using Lucene.Net.Search;
@@ -174,7 +175,7 @@ namespace Lucene.Net.Facet
             }
             else
             {
-                Debug.Assert(clauses.Length == 1 + drillDownDims.Count);
+                Debugging.Assert(() => clauses.Length == 1 + drillDownDims.Count);
                 baseQuery = clauses[0].Query;
                 startClause = 1;
             }
diff --git a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
index 64e4603..23ed7d6 100644
--- a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
+++ b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs
@@ -1,4 +1,4 @@
-// Lucene version compatibility level: 4.10.4
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -89,7 +89,7 @@ namespace Lucene.Net.Facet
             // TODO: if we ever allow null baseScorer ... it will
             // mean we DO score docs out of order ... hmm, or if we
             // change up the order of the conjuntions below
-            Debug.Assert(baseScorer != null);
+            Debugging.Assert(() => baseScorer != null);
 
             // some scorers, eg ReqExlScorer, can hit NPE if cost is called after nextDoc
             long baseQueryCost = baseScorer.GetCost();
@@ -395,7 +395,7 @@ namespace Lucene.Net.Facet
                 while (slot0 < CHUNK && (slot0 = seen.NextSetBit(slot0)) != -1)
                 {
                     int ddDocID = docIDs[slot0];
-                    Debug.Assert(ddDocID != -1);
+                    Debugging.Assert(() => ddDocID != -1);
 
                     int baseDocID = baseScorer.DocID;
                     if (baseDocID < ddDocID)
@@ -550,7 +550,7 @@ namespace Lucene.Net.Facet
                     //}
 
                     // Mark slot as valid:
-                    Debug.Assert(docIDs[slot] != docID, "slot=" + slot + " docID=" + docID);
+                    Debugging.Assert(() => docIDs[slot] != docID, () => "slot=" + slot + " docID=" + docID);
                     docIDs[slot] = docID;
                     scores[slot] = baseScorer.GetScore();
                     filledSlots[filledCount++] = slot;
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index ed85c56..2f5610c 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -693,7 +694,7 @@ namespace Lucene.Net.Facet
                 }
             }
             parts.Add(new string(buffer, 0, upto));
-            Debug.Assert(!lastEscape);
+            Debugging.Assert(() => !lastEscape);
             return parts.ToArray();
         }
     }
diff --git a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
index 02cddec..fa124e8 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using Lucene.Net.Diagnostics;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text;
 
@@ -119,7 +120,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else
                 {
-                    Debug.Assert(flags == 2);
+                    Debugging.Assert(() => flags == 2);
                     // This point is only the end of an interval; attach
                     // it to last interval:
                     elementaryIntervals.Add(new InclusiveRange(prev, v));
@@ -274,7 +275,7 @@ namespace Lucene.Net.Facet.Range
 
             public InclusiveRange(long start, long end)
             {
-                Debug.Assert(end >= start);
+                Debugging.Assert(() => end >= start);
                 this.Start = start;
                 this.End = end;
             }
@@ -348,7 +349,7 @@ namespace Lucene.Net.Facet.Range
                 }
                 else if (left != null)
                 {
-                    Debug.Assert(right != null);
+                    Debugging.Assert(() => right != null);
                     // Recurse:
                     left.AddOutputs(index, range);
                     right.AddOutputs(index, range);
@@ -360,7 +361,7 @@ namespace Lucene.Net.Facet.Range
                 Indent(sb, depth);
                 if (left == null)
                 {
-                    Debug.Assert(right == null);
+                    Debugging.Assert(() => right == null);
                     sb.Append("leaf: " + start + " to " + end);
                 }
                 else
@@ -376,7 +377,7 @@ namespace Lucene.Net.Facet.Range
 
                 if (left != null)
                 {
-                    Debug.Assert(right != null);
+                    Debugging.Assert(() => right != null);
                     left.ToString(sb, depth + 1);
                     right.ToString(sb, depth + 1);
                 }
diff --git a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
index cd78c69..9033c19 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -64,7 +65,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            Debug.Assert(prefixLen > 0 && prefixLen <= copyFrom.Components.Length, "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            Debugging.Assert(() => prefixLen > 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
@@ -74,7 +75,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public CategoryPath(params string[] components)
         {
-            Debug.Assert(components.Length > 0, "use CategoryPath.EMPTY to create an empty path");
+            Debugging.Assert(() => components.Length > 0, () => "use CategoryPath.EMPTY to create an empty path");
             foreach (string comp in components)
             {
                 if (string.IsNullOrEmpty(comp))
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index 1eeae98..d9846c8 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -1,5 +1,6 @@
 using J2N.Threading.Atomic;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Store;
@@ -189,7 +190,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             // verify (to some extent) that merge policy in effect would preserve category docids 
             if (indexWriter != null)
             {
-                Debug.Assert(!(indexWriter.Config.MergePolicy is TieredMergePolicy), "for preserving category docids, merging none-adjacent segments is not allowed");
+                Debugging.Assert(() => !(indexWriter.Config.MergePolicy is TieredMergePolicy), () => "for preserving category docids, merging none-adjacent segments is not allowed");
             }
 
             // after we opened the writer, and the index is locked, it's safe to check
@@ -825,7 +826,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
                                 FacetLabel cp = new FacetLabel(FacetsConfig.StringToPath(t.Utf8ToString()));
                                 docsEnum = termsEnum.Docs(null, docsEnum, DocsFlags.NONE);
                                 bool res = cache.Put(cp, docsEnum.NextDoc() + ctx.DocBase);
-                                Debug.Assert(!res, "entries should not have been evicted from the cache");
+                                Debugging.Assert(() => !res, () => "entries should not have been evicted from the cache");
                             }
                             else
                             {
@@ -906,7 +907,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             }
 
             int[] parents = GetTaxoArrays().Parents;
-            Debug.Assert(ordinal < parents.Length, "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
+            Debugging.Assert(() => ordinal < parents.Length, () => "requested ordinal (" + ordinal + "); parents.length (" + parents.Length + ") !");
             return parents[ordinal];
         }
 
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
index 14f9b7c..10170b9 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -76,7 +77,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         public TaxonomyIndexArrays(IndexReader reader, TaxonomyIndexArrays copyFrom)
         {
-            Debug.Assert(copyFrom != null);
+            Debugging.Assert(() => copyFrom != null);
 
             // note that copyParents.length may be equal to reader.maxDoc(). this is not a bug
             // it may be caused if e.g. the taxonomy segments were merged, and so an updated
diff --git a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
index 57dfdc4..3c8aaa1 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -67,7 +68,7 @@ namespace Lucene.Net.Facet.Taxonomy
             // while the code which calls this method is safe, at some point a test
             // tripped on AIOOBE in toString, but we failed to reproduce. adding the
             // assert as a safety check.
-            Debug.Assert(prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
+            Debugging.Assert(() => prefixLen >= 0 && prefixLen <= copyFrom.Components.Length, () => "prefixLen cannot be negative nor larger than the given components' length: prefixLen=" + prefixLen + " components.length=" + copyFrom.Components.Length);
             this.Components = copyFrom.Components;
             Length = prefixLen;
         }
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
index de8db1a..ca0976d 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -57,7 +58,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 if (ft.IsHierarchical && ft.IsMultiValued == false)
                 {
                     int dimRootOrd = m_taxoReader.GetOrdinal(new FacetLabel(dim));
-                    Debug.Assert(dimRootOrd > 0);
+                    Debugging.Assert(() => dimRootOrd > 0);
                     m_values[dimRootOrd] += Rollup(m_children[dimRootOrd]);
                 }
             }
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
index 255bb6e..de702f8 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
@@ -1,4 +1,5 @@
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -142,7 +143,7 @@ namespace Lucene.Net.Facet.Taxonomy
         public static T OpenIfChanged<T>(T oldTaxoReader) where T : TaxonomyReader
         {
             T newTaxoReader = (T)oldTaxoReader.DoOpenIfChanged();
-            Debug.Assert(newTaxoReader != oldTaxoReader);
+            Debugging.Assert(() => newTaxoReader != oldTaxoReader);
             return newTaxoReader;
         }
 
diff --git a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
index 2d1839a..fbc983a 100644
--- a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -247,7 +248,7 @@ namespace Lucene.Net.Search.Grouping
                     bottomGroup = m_orderedGroups.Last();
                     m_orderedGroups.Remove(bottomGroup);
                 }
-                Debug.Assert(m_orderedGroups.Count == topNGroups - 1);
+                Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
 
                 groupMap.Remove(bottomGroup.GroupValue);
 
@@ -262,7 +263,7 @@ namespace Lucene.Net.Search.Grouping
 
                 groupMap[bottomGroup.GroupValue] = bottomGroup;
                 m_orderedGroups.Add(bottomGroup);
-                Debug.Assert(m_orderedGroups.Count == topNGroups);
+                Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
 
                 int lastComparerSlot = m_orderedGroups.Last().ComparerSlot;
                 foreach (FieldComparer fc in comparers)
@@ -314,7 +315,7 @@ namespace Lucene.Net.Search.Grouping
                     prevLast = m_orderedGroups.Last();
                     m_orderedGroups.Remove(group);
                 }
-                Debug.Assert(m_orderedGroups.Count == topNGroups - 1);
+                Debugging.Assert(() => m_orderedGroups.Count == topNGroups - 1);
             }
             else
             {
@@ -332,7 +333,7 @@ namespace Lucene.Net.Search.Grouping
             if (m_orderedGroups != null)
             {
                 m_orderedGroups.Add(group);
-                Debug.Assert(m_orderedGroups.Count == topNGroups);
+                Debugging.Assert(() => m_orderedGroups.Count == topNGroups);
                 var newLast = m_orderedGroups.Last();
                 // If we changed the value of the last group, or changed which group was last, then update bottom:
                 if (group == newLast || prevLast != newLast)
@@ -375,7 +376,7 @@ namespace Lucene.Net.Search.Grouping
             var comparer = new BuildSortedSetComparer(this);
             m_orderedGroups = new JCG.SortedSet<CollectedSearchGroup<TGroupValue>>(comparer);
             m_orderedGroups.UnionWith(groupMap.Values);
-            Debug.Assert(m_orderedGroups.Count > 0);
+            Debugging.Assert(() => m_orderedGroups.Count > 0);
 
             foreach (FieldComparer fc in comparers)
             {
diff --git a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
index 6def6b0..c5e14e8 100644
--- a/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/BlockGroupingCollector.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -152,8 +153,8 @@ namespace Lucene.Net.Search.Grouping
             {
 
                 //System.out.println("    ltcheck");
-                Debug.Assert(group1 != group2);
-                Debug.Assert(group1.comparerSlot != group2.comparerSlot);
+                Debugging.Assert(() => group1 != group2);
+                Debugging.Assert(() => group1.comparerSlot != group2.comparerSlot);
 
                 int numComparers = outerInstance.comparers.Length;
                 for (int compIDX = 0; compIDX < numComparers; compIDX++)
@@ -220,7 +221,7 @@ namespace Lucene.Net.Search.Grouping
                 {
                     // Replace bottom element in PQ and then updateTop
                     OneGroup og = groupQueue.Top;
-                    Debug.Assert(og != null);
+                    Debugging.Assert(() => og != null);
                     og.count = subDocUpto;
                     og.topGroupDoc = docBase + topGroupDoc;
                     // Swap pending docs
@@ -520,7 +521,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 if (subDocUpto == 1)
                 {
-                    Debug.Assert(!queueFull);
+                    Debugging.Assert(() => !queueFull);
 
                     //System.out.println("    init copy to bottomSlot=" + bottomSlot);
                     foreach (FieldComparer fc in comparers)
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index 2f3a8aa..540bdd5 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -105,12 +106,12 @@ namespace Lucene.Net.Search.Grouping
             {
                 this.shardIndex = shardIndex;
                 iter = shard.GetEnumerator();
-                //Debug.Assert(iter.hasNext()); // No reasonable way to do this in .NET
+                //Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
             }
 
             public ISearchGroup<T> Next()
             {
-                //Debug.Assert(iter.hasNext()); // No reasonable way to do this in .NET
+                //Debugging.Assert(iter.hasNext()); // No reasonable way to do this in .NET
                 ISearchGroup<T> group = iter.Current;
                 if (group.SortValues == null)
                 {
@@ -185,12 +186,12 @@ namespace Lucene.Net.Search.Grouping
                 {
                     if (groupValue == null)
                     {
-                        Debug.Assert(otherMergedGroup.groupValue != null);
+                        Debugging.Assert(() => otherMergedGroup.groupValue != null);
                     }
                     else
                     {
                         
-                        Debug.Assert(!groupValueIsValueType 
+                        Debugging.Assert(() => !groupValueIsValueType 
                             ? JCG.EqualityComparer<T>.Default.Equals(groupValue, otherMergedGroup.groupValue)
 
                             // LUCENENET specific - use J2N.Collections.StructuralEqualityComparer.Default.Equals() if we have a reference type
@@ -205,7 +206,7 @@ namespace Lucene.Net.Search.Grouping
             {
                 // We never have another MergedGroup instance with
                 // same groupValue
-                Debug.Assert(NeverEquals(other));
+                Debugging.Assert(() => NeverEquals(other));
 
                 if (other is MergedGroup<T> otherMergedGroup)
                 {
@@ -293,7 +294,7 @@ namespace Lucene.Net.Search.Grouping
                 }
 
                 // Tie break by min shard index:
-                Debug.Assert(group.MinShardIndex != other.MinShardIndex);
+                Debugging.Assert(() => group.MinShardIndex != other.MinShardIndex);
                 return group.MinShardIndex - other.MinShardIndex;
             }
         }
@@ -326,7 +327,7 @@ namespace Lucene.Net.Search.Grouping
                         //System.out.println("      new");
                         mergedGroup = new MergedGroup<T>(group.GroupValue);
                         mergedGroup.MinShardIndex = shard.ShardIndex;
-                        Debug.Assert(group.SortValues != null);
+                        Debugging.Assert(() => group.SortValues != null);
                         mergedGroup.TopValues = group.SortValues;
                         groupsSeen[group.GroupValue] = mergedGroup;
                         mergedGroup.IsInQueue = true;
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index 12161e2..5b4ddbd 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -174,7 +175,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     BytesRef facetEndPrefix = BytesRef.DeepCopyOf(m_facetPrefix);
                     facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
                     m_endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
-                    Debug.Assert(m_endFacetOrd < 0);
+                    Debugging.Assert(() => m_endFacetOrd < 0);
                     m_endFacetOrd = -m_endFacetOrd - 1; // Points to the ord one higher than facetEndPrefix
                 }
                 else
@@ -202,7 +203,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                     this.m_mergePos = startFacetOrd == -1 ? 1 : startFacetOrd + 1;
                     if (m_mergePos < m_maxTermPos)
                     {
-                        Debug.Assert(tenum != null);
+                        Debugging.Assert(() => tenum != null);
                         tenum.SeekExact(startFacetOrd == -1 ? 0 : startFacetOrd);
                         m_mergeTerm = tenum.Term;
                     }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
index ed286fc..37ed392 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
@@ -2,6 +2,7 @@
 using J2N;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search.Spans;
 using Lucene.Net.Util;
@@ -291,7 +292,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    Debug.Assert(currentStartOffset >= 0);
+                    Debugging.Assert(() => currentStartOffset >= 0);
                     return currentStartOffset;
                 }
             }
@@ -300,7 +301,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             {
                 get
                 {
-                    Debug.Assert(currentEndOffset >= 0);
+                    Debugging.Assert(() => currentEndOffset >= 0);
                     return currentEndOffset;
                 }
             }
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
index 751cf95..920c9d1 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
@@ -1,4 +1,5 @@
 #if FEATURE_BREAKITERATOR
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -42,7 +43,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
         internal void AddMatch(int startOffset, int endOffset, BytesRef term)
         {
-            Debug.Assert(startOffset >= this.startOffset && startOffset <= this.endOffset);
+            Debugging.Assert(() => startOffset >= this.startOffset && startOffset <= this.endOffset);
             if (numMatches == matchStarts.Length)
             {
                 int newLength = ArrayUtil.Oversize(numMatches + 1, RamUsageEstimator.NUM_BYTES_OBJECT_REF);
@@ -56,7 +57,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 matchEnds = newMatchEnds;
                 matchTerms = newMatchTerms;
             }
-            Debug.Assert(matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
+            Debugging.Assert(() => matchStarts.Length == matchEnds.Length && matchEnds.Length == matchTerms.Length);
             matchStarts[numMatches] = startOffset;
             matchEnds[numMatches] = endOffset;
             matchTerms[numMatches] = term;
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
index b894dbe..7244c75 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
@@ -14,6 +14,7 @@ using System.Globalization;
 using System.IO;
 using System.Text;
 using JCG = J2N.Collections.Generic;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Search.PostingsHighlight
 {
@@ -541,7 +542,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 AtomicReaderContext subContext = leaves[leaf];
                 AtomicReader r = subContext.AtomicReader;
 
-                Debug.Assert(leaf >= lastLeaf); // increasing order
+                Debugging.Assert(() => leaf >= lastLeaf); // increasing order
 
                 // if the segment has changed, we must initialize new enums.
                 if (leaf != lastLeaf)
@@ -670,7 +671,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                 // LUCENE-5166: this hit would span the content limit... however more valid 
                 // hits may exist (they are sorted by start). so we pretend like we never 
                 // saw this term, it won't cause a passage to be added to passageQueue or anything.
-                Debug.Assert(EMPTY.StartOffset == int.MaxValue);
+                Debugging.Assert(() => EMPTY.StartOffset == int.MaxValue);
                 if (start < contentLength && end > contentLength)
                 {
                     continue;
@@ -713,7 +714,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                         return passages;
                     }
                     // advance breakiterator
-                    Debug.Assert(BreakIterator.Done < 0);
+                    Debugging.Assert(() => BreakIterator.Done < 0);
                     current.startOffset = Math.Max(bi.Preceding(start + 1), 0);
                     current.endOffset = Math.Min(bi.Next(), contentLength);
                 }
@@ -726,7 +727,7 @@ namespace Lucene.Net.Search.PostingsHighlight
                     {
                         // multitermquery match, pull from payload
                         term = off.dp.GetPayload();
-                        Debug.Assert(term != null);
+                        Debugging.Assert(() => term != null);
                     }
                     current.AddMatch(start, end, term);
                     if (off.pos == dp.Freq)
@@ -750,7 +751,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             }
 
             // Dead code but compiler disagrees:
-            Debug.Assert(false);
+            Debugging.Assert(() => false);
             return null;
         }
 
@@ -765,7 +766,7 @@ namespace Lucene.Net.Search.PostingsHighlight
             // BreakIterator should be un-next'd:
             List<Passage> passages = new List<Passage>();
             int pos = bi.Current;
-            Debug.Assert(pos == 0);
+            Debugging.Assert(() => pos == 0);
             while (passages.Count < maxPassages)
             {
                 int next = bi.Next();
@@ -882,7 +883,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public LimitedStoredFieldVisitor(string[] fields, char[] valueSeparators, int maxLength)
             {
-                Debug.Assert(fields.Length == valueSeparators.Length);
+                Debugging.Assert(() => fields.Length == valueSeparators.Length);
                 this.fields = fields;
                 this.valueSeparators = valueSeparators;
                 this.maxLength = maxLength;
@@ -895,7 +896,7 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             public override void StringField(Index.FieldInfo fieldInfo, string value)
             {
-                Debug.Assert(currentField >= 0);
+                Debugging.Assert(() => currentField >= 0);
                 StringBuilder builder = builders[currentField];
                 if (builder.Length > 0 && builder.Length < maxLength)
                 {
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
index a191c11..60f133f 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragListBuilder.cs
@@ -1,4 +1,5 @@
-using System;
+using Lucene.Net.Diagnostics;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using WeightedPhraseInfo = Lucene.Net.Search.VectorHighlight.FieldPhraseList.WeightedPhraseInfo;
@@ -141,7 +142,7 @@ namespace Lucene.Net.Search.VectorHighlight
             {
                 this.iter = iter;
                 T removeTop = RemoveTop();
-                Debug.Assert( removeTop == null);
+                Debugging.Assert(() => removeTop == null);
             }
 
             public T Top()
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
index 44a9a57..1b5798d 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/FieldTermStack.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -139,7 +140,7 @@ namespace Lucene.Net.Search.VectorHighlight
                 TermInfo current = termList[i];
                 if (current.Position == currentPos)
                 {
-                    Debug.Assert(previous != null);
+                    Debugging.Assert(() => previous != null);
                     previous.SetNext(current);
                     previous = current;
                     //iterator.Remove();
diff --git a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
index 5ed0ed5..02974b5 100644
--- a/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToChildBlockJoinQuery.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using System;
@@ -245,7 +246,7 @@ namespace Lucene.Net.Join
                         }
                     }
 
-                    Debug.Assert(_childDoc < _parentDoc, "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
+                    Debugging.Assert(() => _childDoc < _parentDoc, () => "childDoc=" + _childDoc + " parentDoc=" + _parentDoc);
                     _childDoc++;
                     if (_acceptDocs != null && !_acceptDocs.Get(_childDoc))
                     {
@@ -279,7 +280,7 @@ namespace Lucene.Net.Join
 
             public override int Advance(int childTarget)
             {
-                Debug.Assert(childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
+                Debugging.Assert(() => childTarget >= _parentBits.Length || !_parentBits.Get(childTarget));
 
                 //System.out.println("Q.advance childTarget=" + childTarget);
                 if (childTarget == NO_MORE_DOCS)
@@ -288,14 +289,14 @@ namespace Lucene.Net.Join
                     return _childDoc = _parentDoc = NO_MORE_DOCS;
                 }
 
-                Debug.Assert(_childDoc == -1 || childTarget != _parentDoc, "childTarget=" + childTarget);
+                Debugging.Assert(() => _childDoc == -1 || childTarget != _parentDoc, () => "childTarget=" + childTarget);
                 if (_childDoc == -1 || childTarget > _parentDoc)
                 {
                     // Advance to new parent:
                     _parentDoc = _parentScorer.Advance(childTarget);
                     ValidateParentDoc();
                     //System.out.println("  advance to parentDoc=" + parentDoc);
-                    Debug.Assert(_parentDoc > childTarget);
+                    Debugging.Assert(() => _parentDoc > childTarget);
                     if (_parentDoc == NO_MORE_DOCS)
                     {
                         //System.out.println("  END");
@@ -311,7 +312,7 @@ namespace Lucene.Net.Join
                     childTarget = Math.Max(childTarget, firstChild);
                 }
 
-                Debug.Assert(childTarget < _parentDoc);
+                Debugging.Assert(() => childTarget < _parentDoc);
 
                 // Advance within children of current parent:
                 _childDoc = childTarget;
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
index ed90514..9cd5bee 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinCollector.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Search.Grouping;
 using Lucene.Net.Support;
@@ -283,7 +284,7 @@ namespace Lucene.Net.Join
                     og.counts[scorerIDX] = joinScorer.ChildCount;
                     //System.out.println("    count=" + og.counts[scorerIDX]);
                     og.docs[scorerIDX] = joinScorer.SwapChildDocs(og.docs[scorerIDX]);
-                    Debug.Assert(og.docs[scorerIDX].Length >= og.counts[scorerIDX], "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                    Debugging.Assert(() => og.docs[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.docs[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     //System.out.println("    len=" + og.docs[scorerIDX].length);
                     /*
                       for(int idx=0;idx<og.counts[scorerIDX];idx++) {
@@ -294,7 +295,7 @@ namespace Lucene.Net.Join
                     {
                         //System.out.println("    copy scores");
                         og.scores[scorerIDX] = joinScorer.SwapChildScores(og.scores[scorerIDX]);
-                        Debug.Assert(og.scores[scorerIDX].Length >= og.counts[scorerIDX], "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
+                        Debugging.Assert(() => og.scores[scorerIDX].Length >= og.counts[scorerIDX], () => "length=" + og.scores[scorerIDX].Length + " vs count=" + og.counts[scorerIDX]);
                     }
                 }
                 else
diff --git a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
index 4d51c53..01df4a5 100644
--- a/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
+++ b/src/Lucene.Net.Join/ToParentBlockJoinQuery.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using System;
@@ -283,7 +284,7 @@ namespace Lucene.Net.Join
                     }
 
                     //System.out.println("  parentDoc=" + parentDoc);
-                    Debug.Assert(_parentDoc != -1);
+                    Debugging.Assert(() => _parentDoc != -1);
 
                     //System.out.println("  nextChildDoc=" + nextChildDoc);
                     if (_acceptDocs != null && !_acceptDocs.Get(_parentDoc))
@@ -401,7 +402,7 @@ namespace Lucene.Net.Join
                 _prevParentDoc = _parentBits.PrevSetBit(parentTarget - 1);
 
                 //System.out.println("  rolled back to prevParentDoc=" + prevParentDoc + " vs parentDoc=" + parentDoc);
-                Debug.Assert(_prevParentDoc >= _parentDoc);
+                Debugging.Assert(() => _prevParentDoc >= _parentDoc);
                 if (_prevParentDoc > _nextChildDoc)
                 {
                     _nextChildDoc = _childScorer.Advance(_prevParentDoc);
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index 2bf296e..d1a97ee 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Search.Similarities;
 using Lucene.Net.Util;
@@ -249,7 +250,7 @@ namespace Lucene.Net.Index.Memory
                             return mid;
                         }
                     }
-                    Debug.Assert(comparer.Compare(bytesRef, b) != 0);
+                    Debugging.Assert(() => comparer.Compare(bytesRef, b) != 0);
                     return -(low + 1);
                 }
 
@@ -284,7 +285,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(long ord)
                 {
-                    Debug.Assert(ord < info.terms.Count);
+                    Debugging.Assert(() => ord < info.terms.Count);
                     termUpto = (int)ord;
                 }
 
@@ -331,7 +332,7 @@ namespace Lucene.Net.Index.Memory
 
                 public override void SeekExact(BytesRef term, TermState state)
                 {
-                    Debug.Assert(state != null);
+                    Debugging.Assert(() => state != null);
                     this.SeekExact(((OrdTermState)state).Ord);
                 }
 
@@ -449,8 +450,8 @@ namespace Lucene.Net.Index.Memory
 
                 public override int NextPosition()
                 {
-                    Debug.Assert(posUpto++ < freq);
-                    Debug.Assert(!sliceReader.IsEndOfSlice, " stores offsets : " + startOffset);
+                    Debugging.Assert(() => posUpto++ < freq);
+                    Debugging.Assert(() => !sliceReader.IsEndOfSlice, () => " stores offsets : " + startOffset);
                     if (outerInstance.outerInstance.storeOffsets)
                     {
                         int pos = sliceReader.ReadInt32();
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index 9c91f32..f38d804 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using System;
@@ -216,7 +217,7 @@ namespace Lucene.Net.Index.Memory
             this.bytesUsed = Counter.NewCounter();
             int maxBufferedByteBlocks = (int)((maxReusedBytes / 2) / ByteBlockPool.BYTE_BLOCK_SIZE);
             int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32));
-            Debug.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
+            Debugging.Assert(() => (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
             byteBlockPool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, maxBufferedByteBlocks, bytesUsed));
             intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT32_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
             postingsWriter = new Int32BlockPool.SliceWriter(intBlockPool);
@@ -738,9 +739,9 @@ namespace Lucene.Net.Index.Memory
                 start = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 end = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 freq = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
-                Debug.Assert(start.Length >= ord.Length);
-                Debug.Assert(end.Length >= ord.Length);
-                Debug.Assert(freq.Length >= ord.Length);
+                Debugging.Assert(() => start.Length >= ord.Length);
+                Debugging.Assert(() => end.Length >= ord.Length);
+                Debugging.Assert(() => freq.Length >= ord.Length);
                 return ord;
             }
 
@@ -753,9 +754,9 @@ namespace Lucene.Net.Index.Memory
                     end = ArrayUtil.Grow(end, ord.Length);
                     freq = ArrayUtil.Grow(freq, ord.Length);
                 }
-                Debug.Assert(start.Length >= ord.Length);
-                Debug.Assert(end.Length >= ord.Length);
-                Debug.Assert(freq.Length >= ord.Length);
+                Debugging.Assert(() => start.Length >= ord.Length);
+                Debugging.Assert(() => end.Length >= ord.Length);
+                Debugging.Assert(() => freq.Length >= ord.Length);
                 return ord;
             }
 
diff --git a/src/Lucene.Net.Misc/Document/LazyDocument.cs b/src/Lucene.Net.Misc/Document/LazyDocument.cs
index 598561a..72baf7a 100644
--- a/src/Lucene.Net.Misc/Document/LazyDocument.cs
+++ b/src/Lucene.Net.Misc/Document/LazyDocument.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Util;
 using System;
@@ -119,8 +120,8 @@ namespace Lucene.Net.Documents
             fields.TryGetValue(fieldNum, out lazyValues);
             IIndexableField[] realValues = d.GetFields(name);
 
-            Debug.Assert(realValues.Length <= lazyValues.Count, 
-                "More lazy values then real values for field: " + name);
+            Debugging.Assert(() => realValues.Length <= lazyValues.Count,
+                () => "More lazy values then real values for field: " + name);
 
             for (int i = 0; i < lazyValues.Count; i++)
             {
@@ -163,8 +164,8 @@ namespace Lucene.Net.Documents
                 {
                     outerInstance.FetchRealValues(name, fieldNum);
                 }
-                Debug.Assert(HasBeenLoaded, "field value was not lazy loaded");
-                Debug.Assert(realValue.Name.Equals(Name, StringComparison.Ordinal), "realvalue name != name: " + realValue.Name + " != " + Name);
+                Debugging.Assert(() => HasBeenLoaded, () => "field value was not lazy loaded");
+                Debugging.Assert(() => realValue.Name.Equals(Name, StringComparison.Ordinal), () => "realvalue name != name: " + realValue.Name + " != " + Name);
 
                 return realValue;
             }
diff --git a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
index 66d40b3..1b85aa0 100644
--- a/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/MultiPassIndexSplitter.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
@@ -296,7 +297,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    Debug.Assert(oldLiveDocs != null);
+                    Debugging.Assert(() => oldLiveDocs != null);
                     // this loop is a little bit ineffective, as Bits has no nextSetBit():
                     for (int i = 0; i < maxDoc; i++)
                     {
diff --git a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
index 4576f50..6377c8c 100644
--- a/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/PKIndexSplitter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Search;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Search;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System.Collections.Generic;
@@ -155,7 +156,7 @@ namespace Lucene.Net.Index
                 if (m_input.HasDeletions)
                 {
                     IBits oldLiveDocs = m_input.LiveDocs;
-                    Debug.Assert(oldLiveDocs != null);
+                    Debugging.Assert(() => oldLiveDocs != null);
                     DocIdSetIterator it = bits.GetIterator();
                     for (int i = it.NextDoc(); i < maxDoc; i = it.NextDoc())
                     {
diff --git a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
index 84a406f..b812d2a 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Search;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Search;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Packed;
 using System;
@@ -82,8 +83,8 @@ namespace Lucene.Net.Index.Sorter
             {
                 int newID = docMap.OldToNew(i);
                 int oldID = docMap.NewToOld(newID);
-                Debug.Assert(newID >= 0 && newID < maxDoc, "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
-                Debug.Assert(i == oldID, "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
+                Debugging.Assert(() => newID >= 0 && newID < maxDoc, () => "doc IDs must be in [0-" + maxDoc + "[, got " + newID);
+                Debugging.Assert(() => i == oldID, () => "mapping is inconsistent: " + i + " --oldToNew--> " + newID + " --newToOld--> " + oldID);
                 if (i != oldID || newID < 0 || newID >= maxDoc)
                 {
                     return false;
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 7d87a0e..0ff309e 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Search;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Search;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
@@ -760,7 +761,7 @@ namespace Lucene.Net.Index.Sorter
             {
                 throw new ArgumentException("reader.MaxDoc should be equal to docMap.Count, got" + reader.MaxDoc + " != " + docMap.Count);
             }
-            Debug.Assert(Sorter.IsConsistent(docMap));
+            Debugging.Assert(() => Sorter.IsConsistent(docMap));
             return new SortingAtomicReader(reader, docMap);
         }
 
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index 4692901..58719d3 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -1,11 +1,11 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Packed;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 
 namespace Lucene.Net.Index.Sorter
 {
@@ -134,7 +134,7 @@ namespace Lucene.Net.Index.Sorter
                 {
                     return base.GetDocMap(mergeState);
                 }
-                Debug.Assert(mergeState.DocMaps.Length == 1); // we returned a singleton reader
+                Debugging.Assert(() => mergeState.DocMaps.Length == 1); // we returned a singleton reader
                 MonotonicAppendingInt64Buffer deletes = GetDeletes(unsortedReaders);
                 return new DocMapAnonymousInnerClassHelper(this, mergeState, deletes);
             }
diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
index d77ffb6..91dc58b 100644
--- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Store;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Store;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -87,7 +88,7 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            Debug.Assert(!(prefix is IList));
+            Debugging.Assert(() => !(prefix is IList));
             if (!(output is IList))
             {
                 return outputs.Add((T)prefix, (T)output);
@@ -106,7 +107,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            Debug.Assert(!(output is IList));
+            Debugging.Assert(() => !(output is IList));
             outputs.Write((T)output, @out);
         }
 
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index 78954fd..d6ca39f 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Store;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Store;
 using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -69,8 +70,8 @@ namespace Lucene.Net.Util.Fst
             {
                 this.first = first;
                 this.second = second;
-                Debug.Assert(first >= 0);
-                Debug.Assert(second >= 0);
+                Debugging.Assert(() => first >= 0);
+                Debugging.Assert(() => second >= 0);
             }
 
             public override string ToString()
@@ -133,8 +134,8 @@ namespace Lucene.Net.Util.Fst
 
         public override object Common(object output1, object output2)
         {
-            Debug.Assert(Valid(output1, false));
-            Debug.Assert(Valid(output2, false));
+            Debugging.Assert(() => Valid(output1, false));
+            Debugging.Assert(() => Valid(output2, false));
             long? output1_ = (long?)output1;
             long? output2_ = (long?)output2;
             if (output1_ == NO_OUTPUT || output2_ == NO_OUTPUT)
@@ -143,8 +144,8 @@ namespace Lucene.Net.Util.Fst
             }
             else if (doShare)
             {
-                Debug.Assert(output1_ > 0);
-                Debug.Assert(output2_ > 0);
+                Debugging.Assert(() => output1_ > 0);
+                Debugging.Assert(() => output2_ > 0);
                 return Math.Min(output1_.GetValueOrDefault(), output2_.GetValueOrDefault());
             }
             else if (output1_.Equals(output2_))
@@ -159,11 +160,11 @@ namespace Lucene.Net.Util.Fst
 
         public override object Subtract(object output, object inc)
         {
-            Debug.Assert(Valid(output, false));
-            Debug.Assert(Valid(inc, false));
+            Debugging.Assert(() => Valid(output, false));
+            Debugging.Assert(() => Valid(inc, false));
             long? output2 = (long?)output;
             long? inc2 = (long?)inc;
-            Debug.Assert(output2 >= inc2);
+            Debugging.Assert(() => output2 >= inc2);
 
             if (inc2 == NO_OUTPUT)
             {
@@ -181,8 +182,8 @@ namespace Lucene.Net.Util.Fst
 
         public override object Add(object prefix, object output)
         {
-            Debug.Assert(Valid(prefix, false));
-            Debug.Assert(Valid(output, true));
+            Debugging.Assert(() => Valid(prefix, false));
+            Debugging.Assert(() => Valid(output, true));
             long? prefix2 = (long?)prefix;
             if (output is long?)
             {
@@ -210,7 +211,7 @@ namespace Lucene.Net.Util.Fst
 
         public override void Write(object output, DataOutput @out)
         {
-            Debug.Assert(Valid(output, true));
+            Debugging.Assert(() => Valid(output, true));
             if (output is long?)
             {
                 long? output2 = (long?)output;
@@ -251,9 +252,9 @@ namespace Lucene.Net.Util.Fst
 
         private bool Valid(long? o)
         {
-            Debug.Assert(o != null);
-            Debug.Assert(o is long?);
-            Debug.Assert(o == NO_OUTPUT || o > 0);
+            Debugging.Assert(() => o != null);
+            Debugging.Assert(() => o is long?);
+            Debugging.Assert(() => o == NO_OUTPUT || o > 0);
             return true;
         }
 
@@ -262,7 +263,7 @@ namespace Lucene.Net.Util.Fst
         {
             if (!allowDouble)
             {
-                Debug.Assert(o is long?);
+                Debugging.Assert(() => o is long?);
                 return Valid((long?)o);
             }
             else if (o is TwoInt64s)
@@ -285,8 +286,8 @@ namespace Lucene.Net.Util.Fst
         [MethodImpl(MethodImplOptions.NoInlining)]
         public override object Merge(object first, object second)
         {
-            Debug.Assert(Valid(first, false));
-            Debug.Assert(Valid(second, false));
+            Debugging.Assert(() => Valid(first, false));
+            Debugging.Assert(() => Valid(second, false));
             return new TwoInt64s(((long?)first).GetValueOrDefault(), ((long?)second).GetValueOrDefault());
         }
     }
diff --git a/src/Lucene.Net.Queries/BooleanFilter.cs b/src/Lucene.Net.Queries/BooleanFilter.cs
index 716b2a0..00744e1 100644
--- a/src/Lucene.Net.Queries/BooleanFilter.cs
+++ b/src/Lucene.Net.Queries/BooleanFilter.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using System.Collections;
@@ -77,7 +78,7 @@ namespace Lucene.Net.Queries
                 {
                     if (res == null)
                     {
-                        Debug.Assert(!hasShouldClauses);
+                        Debugging.Assert(() => !hasShouldClauses);
                         res = new FixedBitSet(reader.MaxDoc);
                         res.Set(0, reader.MaxDoc); // NOTE: may set bits on deleted docs
                     }
diff --git a/src/Lucene.Net.Queries/CommonTermsQuery.cs b/src/Lucene.Net.Queries/CommonTermsQuery.cs
index 212345d..db42ad7 100644
--- a/src/Lucene.Net.Queries/CommonTermsQuery.cs
+++ b/src/Lucene.Net.Queries/CommonTermsQuery.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
@@ -278,7 +279,7 @@ namespace Lucene.Net.Queries
                         continue;
                     }
                     termsEnum = terms.GetIterator(termsEnum);
-                    Debug.Assert(termsEnum != null);
+                    Debugging.Assert(() => termsEnum != null);
 
                     if (termsEnum == TermsEnum.EMPTY)
                     {
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
index 502b89c..ea7d844 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
@@ -1,6 +1,7 @@
 using J2N.Text;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.QueryParsers.Flexible.Core.Nodes;
 using Lucene.Net.QueryParsers.Flexible.Core.Processors;
 using Lucene.Net.QueryParsers.Flexible.Standard.Config;
@@ -181,7 +182,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                     {
                         bool hasNext;
                         hasNext = buffer.IncrementToken();
-                        Debug.Assert(hasNext == true);
+                        Debugging.Assert(() => hasNext == true);
                         term = termAtt.ToString();
                     }
 #pragma warning disable 168
@@ -212,7 +213,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    Debug.Assert(hasNext == true);
+                                    Debugging.Assert(() => hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -239,7 +240,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                 try
                                 {
                                     bool hasNext = buffer.IncrementToken();
-                                    Debug.Assert(hasNext == true);
+                                    Debugging.Assert(() => hasNext == true);
                                     term = termAtt.ToString();
                                 }
 #pragma warning disable 168
@@ -306,7 +307,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                             try
                             {
                                 bool hasNext = buffer.IncrementToken();
-                                Debug.Assert(hasNext == true);
+                                Debugging.Assert(() => hasNext == true);
                                 term = termAtt.ToString();
                                 if (posIncrAtt != null)
                                 {
@@ -378,7 +379,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                         try
                         {
                             bool hasNext = buffer.IncrementToken();
-                            Debug.Assert(hasNext == true);
+                            Debugging.Assert(() => hasNext == true);
                             term = termAtt.ToString();
 
                             if (posIncrAtt != null)
diff --git a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
index 0969d82..1be5270 100644
--- a/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Simple/SimpleQueryParser.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
@@ -241,7 +242,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumeSubQuery(State state)
         {
-            Debug.Assert((m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
+            Debugging.Assert(() => (m_flags & Operator.PRECEDENCE_OPERATORS) != 0);
             int start = ++state.Index;
             int precedence = 1;
             bool escaped = false;
@@ -314,7 +315,7 @@ namespace Lucene.Net.QueryParsers.Simple
 
         private void ConsumePhrase(State state)
         {
-            Debug.Assert((m_flags & Operator.PHRASE_OPERATOR) != 0);
+            Debugging.Assert(() => (m_flags & Operator.PHRASE_OPERATOR) != 0);
             int start = ++state.Index;
             int copied = 0;
             bool escaped = false;
diff --git a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
index 0864fc7..4c9be8f 100644
--- a/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexAndTaxonomyRevision.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Facet.Taxonomy.Directory;
 using Lucene.Net.Facet.Taxonomy.WriterCache;
 using Lucene.Net.Index;
@@ -186,7 +187,7 @@ namespace Lucene.Net.Replicator
         /// <exception cref="IOException"></exception>
         public virtual Stream Open(string source, string fileName)
         {
-            Debug.Assert(source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
+            Debugging.Assert(() => source.Equals(INDEX_SOURCE, StringComparison.Ordinal) || source.Equals(TAXONOMY_SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected=({0} or {1}) got={2}", INDEX_SOURCE, TAXONOMY_SOURCE, source));
             IndexCommit commit = source.Equals(INDEX_SOURCE, StringComparison.Ordinal) ? indexCommit : taxonomyCommit;
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
diff --git a/src/Lucene.Net.Replicator/IndexRevision.cs b/src/Lucene.Net.Replicator/IndexRevision.cs
index 1869acf..e8895a7 100644
--- a/src/Lucene.Net.Replicator/IndexRevision.cs
+++ b/src/Lucene.Net.Replicator/IndexRevision.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using System;
@@ -133,7 +134,7 @@ namespace Lucene.Net.Replicator
 
         public virtual Stream Open(string source, string fileName)
         {
-            Debug.Assert(source.Equals(SOURCE, StringComparison.Ordinal), string.Format("invalid source; expected={0} got={1}", SOURCE, source));
+            Debugging.Assert(() => source.Equals(SOURCE, StringComparison.Ordinal), () => string.Format("invalid source; expected={0} got={1}", SOURCE, source));
             return new IndexInputStream(commit.Directory.OpenInput(fileName, IOContext.READ_ONCE));
         }
 
diff --git a/src/Lucene.Net.Replicator/ReplicationClient.cs b/src/Lucene.Net.Replicator/ReplicationClient.cs
index 454ca58..f958f52 100644
--- a/src/Lucene.Net.Replicator/ReplicationClient.cs
+++ b/src/Lucene.Net.Replicator/ReplicationClient.cs
@@ -9,6 +9,7 @@ using System.IO;
 using System.Threading;
 using JCG = J2N.Collections.Generic;
 using Directory = Lucene.Net.Store.Directory;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Replicator
 {
@@ -369,7 +370,7 @@ namespace Lucene.Net.Replicator
                 // make sure to preserve revisionFiles order
                 List<RevisionFile> res = new List<RevisionFile>();
                 string source = e.Key;
-                Debug.Assert(newRevisionFiles.ContainsKey(source), string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
+                Debugging.Assert(() => newRevisionFiles.ContainsKey(source), () => string.Format("source not found in newRevisionFiles: {0}", newRevisionFiles));
                 foreach (RevisionFile file in newRevisionFiles[source])
                 {
                     if (!handlerFiles.Contains(file.FileName))
@@ -415,7 +416,7 @@ namespace Lucene.Net.Replicator
             updateThread = new ReplicationThread(intervalMillis, threadName, DoUpdate, HandleUpdateException, updateLock);
             updateThread.Start();
             // we rely on isAlive to return true in isUpdateThreadAlive, assert to be on the safe side
-            Debug.Assert(updateThread.IsAlive, "updateThread started but not alive?");
+            Debugging.Assert(() => updateThread.IsAlive, () => "updateThread started but not alive?");
         }
 
         /// <summary>
diff --git a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
index 4c08e54..0a9c457 100644
--- a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
 using System;
@@ -190,7 +191,7 @@ namespace Lucene.Net.Sandbox.Queries
                         case Selector.MIDDLE_MAX: return new MiddleMaxValue(randomOrds);
                         case Selector.MIN:
                         default:
-                            Debug.Assert(false);
+                            Debugging.Assert(() => false);
                             return null;
                     }
                 }
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
index a9230cf..cfe132c 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractPrefixTreeFilter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Spatial.Prefix.Tree;
@@ -112,7 +113,7 @@ namespace Lucene.Net.Spatial.Prefix
             protected virtual void CollectDocs(FixedBitSet bitSet)
             {
                 //WARN: keep this specialization in sync
-                Debug.Assert(m_termsEnum != null);
+                Debugging.Assert(() => m_termsEnum != null);
                 m_docsEnum = m_termsEnum.Docs(m_acceptDocs, m_docsEnum, DocsFlags.NONE);
                 int docid;
                 while ((docid = m_docsEnum.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
index 31f84bf..1eb27b7 100644
--- a/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/AbstractVisitingPrefixTreeFilter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Spatial.Prefix.Tree;
@@ -51,7 +52,7 @@ namespace Lucene.Net.Spatial.Prefix
             : base(queryShape, fieldName, grid, detailLevel)
         {
             this.m_prefixGridScanLevel = Math.Max(0, Math.Min(prefixGridScanLevel, grid.MaxLevels - 1));
-            Debug.Assert(detailLevel <= grid.MaxLevels);
+            Debugging.Assert(() => detailLevel <= grid.MaxLevels);
         }
 
         public override bool Equals(object o)
@@ -134,7 +135,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             public virtual DocIdSet GetDocIdSet()
             {
-                Debug.Assert(curVNode == null, "Called more than once?");
+                Debugging.Assert(() => curVNode == null, () => "Called more than once?");
                 if (m_termsEnum == null)
                 {
                     return null;
@@ -168,7 +169,7 @@ namespace Lucene.Net.Spatial.Prefix
                         // LUCENENET IMPORTANT: Must not call this inline with Debug.Assert
                         // because the compiler removes Debug.Assert statements in release mode!!
                         bool hasNext = curVNode.children.MoveNext();
-                        Debug.Assert(hasNext);
+                        Debugging.Assert(() => hasNext);
 
                         curVNode = curVNode.children.Current;
                     }
@@ -205,7 +206,7 @@ namespace Lucene.Net.Spatial.Prefix
                     if (compare > 0)
                     {
                         // leap frog (termsEnum is beyond where we would otherwise seek)
-                        Debug.Assert(!m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), "should be absent");
+                        Debugging.Assert(() => !m_context.AtomicReader.GetTerms(m_outerInstance.m_fieldName).GetIterator(null).SeekExact(curVNodeTerm), () => "should be absent");
                     }
                     else
                     {
@@ -249,7 +250,7 @@ namespace Lucene.Net.Spatial.Prefix
             /// <exception cref="IOException"></exception>
             private void AddIntersectingChildren()
             {
-                Debug.Assert(thisTerm != null);
+                Debugging.Assert(() => thisTerm != null);
                 Cell cell = curVNode.cell;
                 if (cell.Level >= m_outerInstance.m_detailLevel)
                 {
@@ -260,7 +261,7 @@ namespace Lucene.Net.Spatial.Prefix
                 {
                     //If the next indexed term just adds a leaf marker ('+') to cell,
                     // then add all of those docs
-                    Debug.Assert(StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
+                    Debugging.Assert(() => StringHelper.StartsWith(thisTerm, curVNodeTerm));//TODO refactor to use method on curVNode.cell
                     scanCell = m_outerInstance.m_grid.GetCell(thisTerm.Bytes, thisTerm.Offset, thisTerm.Length, scanCell);
                     if (scanCell.Level == cell.Level && scanCell.IsLeaf)
                     {
@@ -371,7 +372,7 @@ namespace Lucene.Net.Spatial.Prefix
 
                 public bool MoveNext()
                 {
-                    //Debug.Assert(cellIter.Current != null);
+                    //Debugging.Assert(cellIter.Current != null);
 
                     // LUCENENET NOTE: The consumer of this class calls
                     // cellIter.MoveNext() before it is instantiated.
@@ -489,9 +490,9 @@ namespace Lucene.Net.Spatial.Prefix
 
             internal virtual void Reset(Cell cell)
             {
-                Debug.Assert(cell != null);
+                Debugging.Assert(() => cell != null);
                 this.cell = cell;
-                Debug.Assert(children == null);
+                Debugging.Assert(() => children == null);
             }
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
index 0ece234..8464ec9 100644
--- a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Spatial.Prefix.Tree;
@@ -101,7 +102,7 @@ namespace Lucene.Net.Spatial.Prefix
                 if (cell.Level != 0 && ((cell.ShapeRel == SpatialRelation.NOT_SET || cell.ShapeRel == SpatialRelation.WITHIN)))
                 {
                     subCellsFilter = null;
-                    Debug.Assert(cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
+                    Debugging.Assert(() => cell.Shape.Relate(outerInstance.m_queryShape) == SpatialRelation.WITHIN);
                 }
                 ICollection<Cell> subCells = cell.GetSubCells(subCellsFilter);
                 foreach (Cell subCell in subCells)
@@ -146,7 +147,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private bool SeekExact(Cell cell)
             {
-                Debug.Assert(new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
+                Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).CompareTo(termBytes) > 0);
                 this.termBytes.Bytes = cell.GetTokenBytes();
                 this.termBytes.Length = this.termBytes.Bytes.Length;
                 if (m_termsEnum == null)
@@ -156,7 +157,7 @@ namespace Lucene.Net.Spatial.Prefix
 
             private SmallDocSet GetDocs(Cell cell, IBits acceptContains)
             {
-                Debug.Assert(new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
+                Debugging.Assert(() => new BytesRef(cell.GetTokenBytes()).Equals(termBytes));
                 return this.CollectDocs(acceptContains);
             }
 
@@ -164,8 +165,8 @@ namespace Lucene.Net.Spatial.Prefix
 
             private SmallDocSet GetLeafDocs(Cell leafCell, IBits acceptContains)
             {
-                Debug.Assert(new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
-                Debug.Assert(!leafCell.Equals(lastLeaf));//don't call for same leaf again
+                Debugging.Assert(() => new BytesRef(leafCell.GetTokenBytes()).Equals(termBytes));
+                Debugging.Assert(() => !leafCell.Equals(lastLeaf));//don't call for same leaf again
                 lastLeaf = leafCell;
 
                 if (m_termsEnum == null)
@@ -297,7 +298,7 @@ namespace Lucene.Net.Spatial.Prefix
                     }
                     docs[d++] = v;
                 }
-                Debug.Assert(d == intSet.Count);
+                Debugging.Assert(() => d == intSet.Count);
                 int size = d;
                 //sort them
                 Array.Sort(docs, 0, size);
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
index 383cec8..004be33 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/Cell.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Spatial4n.Core.Shapes;
 using System;
 using System.Collections.Generic;
@@ -103,7 +104,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public virtual void Reset(byte[] bytes, int off, int len)
         {
-            Debug.Assert(Level != 0);
+            Debugging.Assert(() => Level != 0);
             token = null;
             m_shapeRel = SpatialRelation.NOT_SET;
             this.bytes = bytes;
@@ -138,7 +139,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
         /// <summary>Note: not supported at level 0.</summary>
         public virtual void SetLeaf()
         {
-            Debug.Assert(Level != 0);
+            Debugging.Assert(() => Level != 0);
             m_leaf = true;
         }
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
index 5f45982..4d39985 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/QuadPrefixTree.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Spatial4n.Core.Context;
 using Spatial4n.Core.Shapes;
 using System;
@@ -170,7 +171,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            Debug.Assert(str.Length == level);
+            Debugging.Assert(() => str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
@@ -196,7 +197,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
             IShape shape, 
             int maxLevel)
         {
-            Debug.Assert(str.Length == level);
+            Debugging.Assert(() => str.Length == level);
             double w = levelW[level] / 2;
             double h = levelH[level] / 2;
 
diff --git a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
index 3857f2a..34d923d 100644
--- a/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
+++ b/src/Lucene.Net.Spatial/Prefix/Tree/SpatialPrefixTree.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Spatial4n.Core.Context;
 using Spatial4n.Core.Shapes;
 using System;
@@ -47,7 +48,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
 
         public SpatialPrefixTree(SpatialContext ctx, int maxLevels)
         {
-            Debug.Assert(maxLevels > 0);
+            Debugging.Assert(() => maxLevels > 0);
             this.m_ctx = ctx;
             this.m_maxLevels = maxLevels;
         }
@@ -268,7 +269,7 @@ namespace Lucene.Net.Spatial.Prefix.Tree
                 return new ReadOnlyCollection<Cell>(new[] { cell });
             }
             string endToken = cell.TokenString;
-            Debug.Assert(endToken.Length == detailLevel);
+            Debugging.Assert(() => endToken.Length == detailLevel);
             IList<Cell> cells = new List<Cell>(detailLevel);
             for (int i = 1; i < detailLevel; i++)
             {
diff --git a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
index 41b2ff7..daf619c 100644
--- a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Search;
 using Lucene.Net.Spatial.Prefix.Tree;
@@ -202,8 +203,8 @@ namespace Lucene.Net.Spatial.Prefix
             protected internal override void VisitLeaf(Cell cell)
             {
                 //visitRelation is declared as a field, populated by visit() so we don't recompute it
-                Debug.Assert(m_outerInstance.m_detailLevel != cell.Level);
-                Debug.Assert(visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
+                Debugging.Assert(() => m_outerInstance.m_detailLevel != cell.Level);
+                Debugging.Assert(() => visitRelation == cell.Shape.Relate(m_outerInstance.m_queryShape));
                 if (AllCellsIntersectQuery(cell, visitRelation))
                 {
                     CollectDocs(inside);
diff --git a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
index 327093e..35270a8 100644
--- a/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
+++ b/src/Lucene.Net.Spatial/Vector/DistanceValueSource.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Index;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Index;
 using Lucene.Net.Queries.Function;
 using Lucene.Net.Search;
 using Lucene.Net.Util;
@@ -103,7 +104,7 @@ namespace Lucene.Net.Spatial.Vector
                 // make sure it has minX and area
                 if (validX.Get(doc))
                 {
-                    Debug.Assert(validY.Get(doc));
+                    Debugging.Assert(() => validY.Get(doc));
                     return calculator.Distance(outerInstance.from, ptX.Get(doc), ptY.Get(doc)) * outerInstance.multiplier;
                 }
                 return nullValue;
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index 3ec11c5..f8d6c75 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -1,5 +1,6 @@
 using J2N.Collections.Generic.Extensions;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Support.IO;
@@ -269,7 +270,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 IList<Transition> newTransitions = new List<Transition>();
                 foreach (Transition t in state.GetTransitions())
                 {
-                    Debug.Assert(t.Min == t.Max);
+                    Debugging.Assert(() => t.Min == t.Max);
                     if (t.Min == TokenStreamToAutomaton.POS_SEP)
                     {
                         if (preserveSep)
@@ -358,8 +359,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 // Next by cost:
                 long aCost = readerA.ReadInt32();
                 long bCost = readerB.ReadInt32();
-                Debug.Assert(DecodeWeight(aCost) >= 0);
-                Debug.Assert(DecodeWeight(bCost) >= 0);
+                Debugging.Assert(() => DecodeWeight(aCost) >= 0);
+                Debugging.Assert(() => DecodeWeight(bCost) >= 0);
                 if (aCost < bCost)
                 {
                     return -1;
@@ -486,7 +487,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             output.WriteBytes(surfaceForm.Bytes, surfaceForm.Offset, surfaceForm.Length);
                         }
 
-                        Debug.Assert(output.Position == requiredLength, output.Position + " vs " + requiredLength);
+                        Debugging.Assert(() => output.Position == requiredLength, () => output.Position + " vs " + requiredLength);
 
                         writer.Write(buffer, 0, output.Position);
                     }
@@ -660,7 +661,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         break;
                     }
                 }
-                Debug.Assert(sepIndex != -1);
+                Debugging.Assert(() => sepIndex != -1);
                 spare.Grow(sepIndex);
 
                 int payloadLen = output2.Length - sepIndex - 1;
@@ -706,7 +707,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         public override IList<LookupResult> DoLookup(string key, IEnumerable<BytesRef> contexts, bool onlyMorePopular, int num)
         {
-            Debug.Assert(num > 0);
+            Debugging.Assert(() => num > 0);
 
             if (onlyMorePopular)
             {
@@ -798,7 +799,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     }
 
                     var completions = searcher.Search();
-                    Debug.Assert(completions.IsComplete);
+                    Debugging.Assert(() => completions.IsComplete);
 
                     // NOTE: this is rather inefficient: we enumerate
                     // every matching "exactly the same analyzed form"
@@ -841,7 +842,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
 
                 var completions2 = searcher2.Search();
-                Debug.Assert(completions2.IsComplete);
+                Debugging.Assert(() => completions2.IsComplete);
 
                 foreach (Util.Fst.Util.Result<PairOutputs<long?, BytesRef>.Pair> completion in completions2)
                 {
@@ -919,7 +920,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         // We found exact match, which means we should
                         // have already found it in the first search:
-                        Debug.Assert(results.Count == 1);
+                        Debugging.Assert(() => results.Count == 1);
                         return false;
                     }
                     else
@@ -963,7 +964,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             ReplaceSep(automaton);
             automaton = ConvertAutomaton(automaton);
 
-            Debug.Assert(SpecialOperations.IsFinite(automaton));
+            Debugging.Assert(() => SpecialOperations.IsFinite(automaton));
 
             // Get all paths from the automaton (there can be
             // more than one path, eg if the analyzer created a
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
index 8d6713b..d20b446 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/BlendedInfixSuggester.cs
@@ -8,6 +8,7 @@ using System.Diagnostics;
 using System.IO;
 using JCG = J2N.Collections.Generic;
 using Directory = Lucene.Net.Store.Directory;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Search.Suggest.Analyzing
 {
@@ -144,7 +145,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         {
 
             BinaryDocValues textDV = MultiDocValues.GetBinaryValues(searcher.IndexReader, TEXT_FIELD_NAME);
-            Debug.Assert(textDV != null);
+            Debugging.Assert(() => textDV != null);
 
             // This will just be null if app didn't pass payloads to build():
             // TODO: maybe just stored fields?  they compress...
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index 72736b2..a676d8e 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using Lucene.Net.Util.Automaton;
 using Lucene.Net.Util.Fst;
 using System.Collections.Generic;
@@ -68,7 +69,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         /// </summary>
         public static IList<Path<T>> IntersectPrefixPaths<T>(Automaton a, FST<T> fst)
         {
-            Debug.Assert(a.IsDeterministic);
+            Debugging.Assert(() => a.IsDeterministic);
             IList<Path<T>> queue = new List<Path<T>>();
             List<Path<T>> endNodes = new List<Path<T>>();
             queue.Add(new Path<T>(a.GetInitialState(), fst.GetFirstArc(new FST.Arc<T>()), fst.Outputs.NoOutput, new Int32sRef()));
@@ -119,8 +120,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         FST.Arc<T> nextArc = Lucene.Net.Util.Fst.Util.ReadCeilArc(min, fst, path.FstNode, scratchArc, fstReader);
                         while (nextArc != null && nextArc.Label <= max)
                         {
-                            Debug.Assert(nextArc.Label <= max);
-                            Debug.Assert(nextArc.Label >= min, nextArc.Label + " " + min);
+                            Debugging.Assert(() => nextArc.Label <= max);
+                            Debugging.Assert(() => nextArc.Label >= min, () => nextArc.Label + " " + min);
                             Int32sRef newInput = new Int32sRef(currentInput.Length + 1);
                             newInput.CopyInt32s(currentInput);
                             newInput.Int32s[currentInput.Length] = nextArc.Label;
@@ -129,7 +130,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                               .CopyFrom(nextArc), fst.Outputs.Add(path.Output, nextArc.Output), newInput));
                             int label = nextArc.Label; // used in assert
                             nextArc = nextArc.IsLast ? null : fst.ReadNextRealArc(nextArc, fstReader);
-                            Debug.Assert(nextArc == null || label < nextArc.Label, "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
+                            Debugging.Assert(() => nextArc == null || label < nextArc.Label, () => "last: " + label + " next: " + (nextArc == null ? "" : nextArc.Label.ToString()));
                         }
                     }
                 }
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index 2d058f3..c53d8c0 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -3,6 +3,7 @@ using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.Shingle;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Codecs;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -555,7 +556,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     // a separate dedicated att for this?
                     int gramCount = posLenAtt.PositionLength;
 
-                    Debug.Assert(gramCount <= grams);
+                    Debugging.Assert(() => gramCount <= grams);
 
                     // Safety: make sure the recalculated count "agrees":
                     if (CountGrams(tokenBytes) != gramCount)
@@ -681,7 +682,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             BytesRef context = new BytesRef(token.Bytes, token.Offset, i);
                             long? output = Lucene.Net.Util.Fst.Util.Get(fst, Lucene.Net.Util.Fst.Util.ToInt32sRef(context, new Int32sRef()));
-                            Debug.Assert(output != null);
+                            Debugging.Assert(() => output != null);
                             contextCount = DecodeWeight(output);
                             lastTokenFragment = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                             break;
@@ -698,7 +699,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     {
                         finalLastToken = BytesRef.DeepCopyOf(lastTokenFragment);
                     }
-                    Debug.Assert(finalLastToken.Offset == 0);
+                    Debugging.Assert(() => finalLastToken.Offset == 0);
 
                     CharsRef spare = new CharsRef();
 
@@ -725,7 +726,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         searcher.AddStartPaths(arc, prefixOutput, true, new Int32sRef());
 
                         completions = searcher.Search();
-                        Debug.Assert(completions.IsComplete);
+                        Debugging.Assert(() => completions.IsComplete);
                     }
                     catch (IOException bogus)
                     {
@@ -753,7 +754,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             if (token.Bytes[token.Offset + i] == separator)
                             {
-                                Debug.Assert(token.Length - i - 1 > 0);
+                                Debugging.Assert(() => token.Length - i - 1 > 0);
                                 lastToken = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
                                 break;
                             }
@@ -771,7 +772,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             // return numbers that are greater than long.MaxValue, which results in a negative long number.
                             (long)(long.MaxValue * (decimal)backoff * ((decimal)DecodeWeight(completion.Output)) / contextCount));
                         results.Add(result);
-                        Debug.Assert(results.Count == seen.Count);
+                        Debugging.Assert(() => results.Count == seen.Count);
                     //System.out.println("  add result=" + result);
                     nextCompletionContinue:;
                     }
@@ -873,7 +874,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         //private long decodeWeight(Pair<Long,BytesRef> output) {
         private static long DecodeWeight(long? output)
         {
-            Debug.Assert(output != null);
+            Debugging.Assert(() => output != null);
             return (int)(long.MaxValue - output); // LUCENENET TODO: Perhaps a Java Lucene bug? Why cast to int when returning long?
         }
 
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
index 75524a2..4455dfa 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/SuggestStopFilter.cs
@@ -1,6 +1,7 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 
 namespace Lucene.Net.Search.Suggest.Analyzing
@@ -114,7 +115,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         m_input.End();
                         endState = CaptureState();
                         int finalEndOffset = offsetAtt.EndOffset;
-                        Debug.Assert(finalEndOffset >= endOffset);
+                        Debugging.Assert(() => finalEndOffset >= endOffset);
                         if (finalEndOffset > endOffset)
                         {
                             // OK there was a token separator after the
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
index 76bb1d9..d9d974d 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletion.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System;
 using System.Collections.Generic;
@@ -406,7 +407,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 output.Bytes = ArrayUtil.Grow(output.Bytes);
             }
-            Debug.Assert(output.Offset == 0);
+            Debugging.Assert(() => output.Offset == 0);
             output.Bytes[output.Length++] = (byte) arc.Label;
             FST.BytesReader fstReader = automaton.GetBytesReader();
             automaton.ReadFirstTargetArc(arc, arc, fstReader);
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index 36c6b8e..ad27c56 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Store;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
@@ -139,7 +140,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             {
                 throw new ArgumentException("this suggester doesn't support contexts");
             }
-            Debug.Assert(num > 0);
+            Debugging.Assert(() => num > 0);
 
             if (onlyMorePopular)
             {
@@ -189,7 +190,7 @@ namespace Lucene.Net.Search.Suggest.Fst
             try
             {
                 completions = Lucene.Net.Util.Fst.Util.ShortestPaths(fst, arc, prefixOutput, weightComparer, num, !exactFirst);
-                Debug.Assert(completions.IsComplete);
+                Debugging.Assert(() => completions.IsComplete);
             }
             catch (IOException bogus)
             {
@@ -212,7 +213,7 @@ namespace Lucene.Net.Search.Suggest.Fst
 
         private long? LookupPrefix(BytesRef scratch, FST.Arc<long?> arc) //Bogus
         {
-            Debug.Assert(0 == (long)fst.Outputs.NoOutput);
+            Debugging.Assert(() => 0 == (long)fst.Outputs.NoOutput);
             long output = 0;
             var bytesReader = fst.GetBytesReader();
 
@@ -293,7 +294,7 @@ namespace Lucene.Net.Search.Suggest.Fst
                 : base(source)
             {
                 this.outerInstance = outerInstance;
-                Debug.Assert(source.HasPayloads == false);
+                Debugging.Assert(() => source.HasPayloads == false);
             }
 
             protected internal override void Encode(OfflineSorter.ByteSequencesWriter writer, ByteArrayDataOutput output, byte[] buffer, BytesRef spare, BytesRef payload, ICollection<BytesRef> contexts, long weight)
diff --git a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
index 4bd25a0..b2c32d9 100644
--- a/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
+++ b/src/Lucene.Net.Suggest/Suggest/UnsortedInputIterator.cs
@@ -1,4 +1,5 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -61,7 +62,7 @@ namespace Lucene.Net.Search.Suggest
         {
             get
             {
-                Debug.Assert(currentOrd == ords[m_curPos]);
+                Debugging.Assert(() => currentOrd == ords[m_curPos]);
                 return m_freqs[currentOrd];
             }
         }
@@ -82,7 +83,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasPayloads && m_curPos < m_payloads.Length)
                 {
-                    Debug.Assert(currentOrd == ords[m_curPos]);
+                    Debugging.Assert(() => currentOrd == ords[m_curPos]);
                     return m_payloads.Get(payloadSpare, currentOrd);
                 }
                 return null;
@@ -95,7 +96,7 @@ namespace Lucene.Net.Search.Suggest
             {
                 if (HasContexts && m_curPos < m_contextSets.Count)
                 {
-                    Debug.Assert(currentOrd == ords[m_curPos]);
+                    Debugging.Assert(() => currentOrd == ords[m_curPos]);
                     return m_contextSets[currentOrd];
                 }
                 return null;
diff --git a/src/Lucene.Net/Analysis/NumericTokenStream.cs b/src/Lucene.Net/Analysis/NumericTokenStream.cs
index 9902fff..fbff885 100644
--- a/src/Lucene.Net/Analysis/NumericTokenStream.cs
+++ b/src/Lucene.Net/Analysis/NumericTokenStream.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Diagnostics;
@@ -177,7 +178,7 @@ namespace Lucene.Net.Analysis
 
             public void FillBytesRef()
             {
-                Debug.Assert(ValueSize == 64 || ValueSize == 32);
+                Debugging.Assert(() => ValueSize == 64 || ValueSize == 32);
                 if (ValueSize == 64)
                 {
                     NumericUtils.Int64ToPrefixCoded(_value, Shift, _bytes);
diff --git a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
index 3dac999..93d15f2 100644
--- a/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
+++ b/src/Lucene.Net/Analysis/TokenStreamToAutomaton.cs
@@ -1,5 +1,6 @@
 using J2N;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Diagnostics;
@@ -154,7 +155,7 @@ namespace Lucene.Net.Analysis
                 {
                     posInc = 1;
                 }
-                Debug.Assert(pos > -1 || posInc > 0);
+                Debugging.Assert(() => pos > -1 || posInc > 0);
 
                 if (posInc > 0)
                 {
@@ -162,7 +163,7 @@ namespace Lucene.Net.Analysis
                     pos += posInc;
 
                     posData = positions.Get(pos);
-                    Debug.Assert(posData.leaving == null);
+                    Debugging.Assert(() => posData.leaving == null);
 
                     if (posData.arriving == null)
                     {
diff --git a/src/Lucene.Net/Codecs/BlockTermState.cs b/src/Lucene.Net/Codecs/BlockTermState.cs
index e799921..2816115 100644
--- a/src/Lucene.Net/Codecs/BlockTermState.cs
+++ b/src/Lucene.Net/Codecs/BlockTermState.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Codecs
 {
@@ -57,7 +57,7 @@ namespace Lucene.Net.Codecs
 
         public override void CopyFrom(TermState other)
         {
-            Debug.Assert(other is BlockTermState, "can not copy from " + other.GetType().Name);
+            Debugging.Assert(() => other is BlockTermState, () => "can not copy from " + other.GetType().Name);
             BlockTermState other2 = (BlockTermState)other;
             base.CopyFrom(other);
             DocFreq = other2.DocFreq;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
index a654054..2be0607 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using Lucene.Net.Util.Fst;
@@ -167,13 +168,13 @@ namespace Lucene.Net.Codecs
                 {
                     int field = @in.ReadVInt32();
                     long numTerms = @in.ReadVInt64();
-                    Debug.Assert(numTerms >= 0);
+                    Debugging.Assert(() => numTerms >= 0);
                     int numBytes = @in.ReadVInt32();
                     BytesRef rootCode = new BytesRef(new byte[numBytes]);
                     @in.ReadBytes(rootCode.Bytes, 0, numBytes);
                     rootCode.Length = numBytes;
                     FieldInfo fieldInfo = fieldInfos.FieldInfo(field);
-                    Debug.Assert(fieldInfo != null, "field=" + field);
+                    Debugging.Assert(() => fieldInfo != null, () => "field=" + field);
                     long sumTotalTermFreq = fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY ? -1 : @in.ReadVInt64();
                     long sumDocFreq = @in.ReadVInt64();
                     int docCount = @in.ReadVInt32();
@@ -291,7 +292,7 @@ namespace Lucene.Net.Codecs
 
         public override Terms GetTerms(string field)
         {
-            Debug.Assert(field != null);
+            Debugging.Assert(() => field != null);
             FieldReader ret;
             fields.TryGetValue(field, out ret);
             return ret;
@@ -478,7 +479,7 @@ namespace Lucene.Net.Codecs
                 }
                 endBlockCount++;
                 long otherBytes = frame.fpEnd - frame.fp - frame.suffixesReader.Length - frame.statsReader.Length;
-                Debug.Assert(otherBytes > 0, "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
+                Debugging.Assert(() => otherBytes > 0, () => "otherBytes=" + otherBytes + " frame.fp=" + frame.fp + " frame.fpEnd=" + frame.fpEnd);
                 TotalBlockOtherBytes += otherBytes;
             }
 
@@ -489,9 +490,9 @@ namespace Lucene.Net.Codecs
 
             internal virtual void Finish()
             {
-                Debug.Assert(startBlockCount == endBlockCount, "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
-                Debug.Assert(TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
-                Debug.Assert(TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
+                Debugging.Assert(() => startBlockCount == endBlockCount, () => "startBlockCount=" + startBlockCount + " endBlockCount=" + endBlockCount);
+                Debugging.Assert(() => TotalBlockCount == FloorSubBlockCount + NonFloorBlockCount, () => "floorSubBlockCount=" + FloorSubBlockCount + " nonFloorBlockCount=" + NonFloorBlockCount + " totalBlockCount=" + TotalBlockCount);
+                Debugging.Assert(() => TotalBlockCount == MixedBlockCount + TermsOnlyBlockCount + SubBlocksOnlyBlockCount, () => "totalBlockCount=" + TotalBlockCount + " mixedBlockCount=" + MixedBlockCount + " subBlocksOnlyBlockCount=" + SubBlocksOnlyBlockCount + " termsOnlyBlockCount=" + TermsOnlyBlockCount);
             }
 
             public override string ToString()
@@ -529,7 +530,7 @@ namespace Lucene.Net.Codecs
                             @out.AppendLine("      " + prefix.ToString().PadLeft(2, ' ') + ": " + blockCount);
                         }
                     }
-                    Debug.Assert(TotalBlockCount == total);
+                    Debugging.Assert(() => TotalBlockCount == total);
                 }
                 return @out.ToString();
             }
@@ -560,7 +561,7 @@ namespace Lucene.Net.Codecs
             internal FieldReader(BlockTreeTermsReader outerInstance, FieldInfo fieldInfo, long numTerms, BytesRef rootCode, long sumTotalTermFreq, long sumDocFreq, int docCount, long indexStartFP, int longsSize, IndexInput indexIn)
             {
                 this.outerInstance = outerInstance;
-                Debug.Assert(numTerms > 0);
+                Debugging.Assert(() => numTerms > 0);
                 this.fieldInfo = fieldInfo;
                 //DEBUG = BlockTreeTermsReader.DEBUG && fieldInfo.name.Equals("id", StringComparison.Ordinal);
                 this.numTerms = numTerms;
@@ -760,7 +761,7 @@ namespace Lucene.Net.Codecs
 
                     internal void LoadNextFloorBlock()
                     {
-                        Debug.Assert(numFollowFloorBlocks > 0);
+                        Debugging.Assert(() => numFollowFloorBlocks > 0);
                         //if (DEBUG) System.out.println("    loadNextFoorBlock trans=" + transitions[transitionIndex]);
 
                         do
@@ -845,7 +846,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code_ = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code_ >> 1);
-                        Debug.Assert(entCount > 0);
+                        Debugging.Assert(() => entCount > 0);
                         isLastInFloor = (code_ & 1) != 0;
 
                         // term suffixes:
@@ -906,7 +907,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debug.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -917,7 +918,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debug.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -944,7 +945,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        Debug.Assert(limit > 0);
+                        Debugging.Assert(() => limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -1021,7 +1022,7 @@ namespace Lucene.Net.Codecs
 
                     FST.Arc<BytesRef> arc = outerInstance.index.GetFirstArc(arcs[0]);
                     // Empty string prefix must have an output in the index!
-                    Debug.Assert(arc.IsFinal);
+                    Debugging.Assert(() => arc.IsFinal);
 
                     // Special pushFrame since it's the first one:
                     Frame f = stack[0];
@@ -1033,7 +1034,7 @@ namespace Lucene.Net.Codecs
                     f.Load(outerInstance.rootCode);
 
                     // for assert:
-                    Debug.Assert(SetSavedStartTerm(startTerm));
+                    Debugging.Assert(() => SetSavedStartTerm(startTerm));
 
                     currentFrame = f;
                     if (startTerm != null)
@@ -1067,7 +1068,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    Debug.Assert(stack[ord].ord == ord);
+                    Debugging.Assert(() => stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1101,7 +1102,7 @@ namespace Lucene.Net.Codecs
                     // possible:
                     FST.Arc<BytesRef> arc = currentFrame.arc;
                     int idx = currentFrame.prefix;
-                    Debug.Assert(currentFrame.suffix > 0);
+                    Debugging.Assert(() => currentFrame.suffix > 0);
                     BytesRef output = currentFrame.outputPrefix;
                     while (idx < f.prefix)
                     {
@@ -1110,14 +1111,14 @@ namespace Lucene.Net.Codecs
                         // case by using current arc as starting point,
                         // passed to findTargetArc
                         arc = outerInstance.index.FindTargetArc(target, arc, GetArc(1 + idx), fstReader);
-                        Debug.Assert(arc != null);
+                        Debugging.Assert(() => arc != null);
                         output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
                         idx++;
                     }
 
                     f.arc = arc;
                     f.outputPrefix = output;
-                    Debug.Assert(arc.IsFinal);
+                    Debugging.Assert(() => arc.IsFinal);
                     f.Load(outerInstance.outerInstance.fstOutputs.Add(output, arc.NextFinalOutput));
                     return f;
                 }
@@ -1168,7 +1169,7 @@ namespace Lucene.Net.Codecs
                     for (int idx = 0; idx < currentFrame.suffix; idx++)
                     {
                         state = runAutomaton.Step(state, currentFrame.suffixBytes[currentFrame.startBytePos + idx] & 0xff);
-                        Debug.Assert(state != -1);
+                        Debugging.Assert(() => state != -1);
                     }
                     return state;
                 }
@@ -1180,13 +1181,13 @@ namespace Lucene.Net.Codecs
                 private void SeekToStartTerm(BytesRef target)
                 {
                     //if (DEBUG) System.out.println("seek to startTerm=" + target.utf8ToString());
-                    Debug.Assert(currentFrame.ord == 0);
+                    Debugging.Assert(() => currentFrame.ord == 0);
                     if (term.Length < target.Length)
                     {
                         term.Bytes = ArrayUtil.Grow(term.Bytes, target.Length);
                     }
                     FST.Arc<BytesRef> arc = arcs[0];
-                    Debug.Assert(arc == currentFrame.arc);
+                    Debugging.Assert(() => arc == currentFrame.arc);
 
                     for (int idx = 0; idx <= target.Length; idx++)
                     {
@@ -1264,7 +1265,7 @@ namespace Lucene.Net.Codecs
                         }
                     }
 
-                    Debug.Assert(false);
+                    Debugging.Assert(() => false);
                 }
 
                 public override BytesRef Next()
@@ -1294,7 +1295,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                Debug.Assert(currentFrame.lastSubFP == lastFP);
+                                Debugging.Assert(() => currentFrame.lastSubFP == lastFP);
                                 //if (DEBUG) System.out.println("\n  frame ord=" + currentFrame.ord + " prefix=" + brToString(new BytesRef(term.bytes, term.offset, currentFrame.prefix)) + " state=" + currentFrame.state + " lastInFloor?=" + currentFrame.isLastInFloor + " fp=" + currentFrame.fp + " trans=" + (currentFrame.transitions.length == 0 ? "n/a" : currentFrame.transitions[currentFrame.transitionIndex]) + " outputPrefix=" + currentFrame.outputPrefix);
                             }
                         }
@@ -1348,7 +1349,7 @@ namespace Lucene.Net.Codecs
                             byte[] commonSuffixBytes = compiledAutomaton.CommonSuffixRef.Bytes;
 
                             int lenInPrefix = compiledAutomaton.CommonSuffixRef.Length - currentFrame.suffix;
-                            Debug.Assert(compiledAutomaton.CommonSuffixRef.Offset == 0);
+                            Debugging.Assert(() => compiledAutomaton.CommonSuffixRef.Offset == 0);
                             int suffixBytesPos;
                             int commonSuffixBytesPos = 0;
 
@@ -1359,7 +1360,7 @@ namespace Lucene.Net.Codecs
                                 // test whether the prefix part matches:
                                 byte[] termBytes = term.Bytes;
                                 int termBytesPos = currentFrame.prefix - lenInPrefix;
-                                Debug.Assert(termBytesPos >= 0);
+                                Debugging.Assert(() => termBytesPos >= 0);
                                 int termBytesPosEnd = currentFrame.prefix;
                                 while (termBytesPos < termBytesPosEnd)
                                 {
@@ -1427,10 +1428,7 @@ namespace Lucene.Net.Codecs
                         {
                             CopyTerm();
                             //if (DEBUG) System.out.println("      term match to state=" + state + "; return term=" + brToString(term));
-                            if (!(savedStartTerm == null || term.CompareTo(savedStartTerm) > 0))
-                            {
-                                Debug.Assert(false, "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
-                            }
+                            Debugging.Assert(() => savedStartTerm == null || term.CompareTo(savedStartTerm) > 0, () => "saveStartTerm=" + savedStartTerm.Utf8ToString() + " term=" + term.Utf8ToString());
                             return term;
                         }
                         else
@@ -1534,7 +1532,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debug.Assert(arc.IsFinal);
+                        Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1582,7 +1580,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debug.Assert(arc.IsFinal);
+                        Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1617,7 +1615,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 long lastFP = currentFrame.fpOrig;
                                 currentFrame = stack[currentFrame.ord - 1];
-                                Debug.Assert(lastFP == currentFrame.lastSubFP);
+                                Debugging.Assert(() => lastFP == currentFrame.lastSubFP);
                                 // if (DEBUG) {
                                 //   System.out.println("  reset validIndexPrefix=" + validIndexPrefix);
                                 // }
@@ -1657,7 +1655,7 @@ namespace Lucene.Net.Codecs
                     {
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
                         // Empty string prefix must have an output in the index!
-                        Debug.Assert(arc.IsFinal);
+                        Debugging.Assert(() => arc.IsFinal);
                     }
                     else
                     {
@@ -1684,7 +1682,7 @@ namespace Lucene.Net.Codecs
                         }
                         stack = next;
                     }
-                    Debug.Assert(stack[ord].ord == ord);
+                    Debugging.Assert(() => stack[ord].ord == ord);
                     return stack[ord];
                 }
 
@@ -1743,7 +1741,7 @@ namespace Lucene.Net.Codecs
                             //   System.out.println("        skip rewind!");
                             // }
                         }
-                        Debug.Assert(length == f.prefix);
+                        Debugging.Assert(() => length == f.prefix);
                     }
                     else
                     {
@@ -1789,7 +1787,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    Debug.Assert(ClearEOF());
+                    Debugging.Assert(() => ClearEOF());
 
                     FST.Arc<BytesRef> arc;
                     int targetUpto;
@@ -1811,12 +1809,12 @@ namespace Lucene.Net.Codecs
                         // }
 
                         arc = arcs[0];
-                        Debug.Assert(arc.IsFinal);
+                        Debugging.Assert(() => arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        Debug.Assert(validIndexPrefix <= term.Length);
+                        Debugging.Assert(() => validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -1840,7 +1838,7 @@ namespace Lucene.Net.Codecs
                             //if (arc.label != (target.bytes[target.offset + targetUpto] & 0xFF)) {
                             //System.out.println("FAIL: arc.label=" + (char) arc.label + " targetLabel=" + (char) (target.bytes[target.offset + targetUpto] & 0xFF));
                             //}
-                            Debug.Assert(arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -1907,7 +1905,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            Debug.Assert(term.Length == target.Length);
+                            Debugging.Assert(() => term.Length == target.Length);
                             if (termExists)
                             {
                                 // if (DEBUG) {
@@ -1932,8 +1930,8 @@ namespace Lucene.Net.Codecs
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
 
                         // Empty string prefix must have an output (block) in the index!
-                        Debug.Assert(arc.IsFinal);
-                        Debug.Assert(arc.Output != null);
+                        Debugging.Assert(() => arc.IsFinal);
+                        Debugging.Assert(() => arc.Output != null);
 
                         // if (DEBUG) {
                         //   System.out.println("    no seek state; push root frame");
@@ -2005,7 +2003,7 @@ namespace Lucene.Net.Codecs
                             arc = nextArc;
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             // Aggregate output as we go:
-                            Debug.Assert(arc.Output != null);
+                            Debugging.Assert(() => arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2073,7 +2071,7 @@ namespace Lucene.Net.Codecs
                         term.Bytes = ArrayUtil.Grow(term.Bytes, 1 + target.Length);
                     }
 
-                    Debug.Assert(ClearEOF());
+                    Debugging.Assert(ClearEOF);
 
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.seekCeil seg=" + segment + " target=" + fieldInfo.name + ":" + target.utf8ToString() + " " + target + " current=" + brToString(term) + " (exists?=" + termExists + ") validIndexPrefix=  " + validIndexPrefix);
@@ -2100,12 +2098,12 @@ namespace Lucene.Net.Codecs
                         //}
 
                         arc = arcs[0];
-                        Debug.Assert(arc.IsFinal);
+                        Debugging.Assert(() => arc.IsFinal);
                         output = arc.Output;
                         targetUpto = 0;
 
                         Frame lastFrame = stack[0];
-                        Debug.Assert(validIndexPrefix <= term.Length);
+                        Debugging.Assert(() => validIndexPrefix <= term.Length);
 
                         int targetLimit = Math.Min(target.Length, validIndexPrefix);
 
@@ -2126,7 +2124,7 @@ namespace Lucene.Net.Codecs
                                 break;
                             }
                             arc = arcs[1 + targetUpto];
-                            Debug.Assert(arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
+                            Debugging.Assert(() => arc.Label == (target.Bytes[target.Offset + targetUpto] & 0xFF), () => "arc.label=" + (char)arc.Label + " targetLabel=" + (char)(target.Bytes[target.Offset + targetUpto] & 0xFF));
                             // TOOD: we could save the outputs in local
                             // byte[][] instead of making new objs ever
                             // seek; but, often the FST doesn't have any
@@ -2195,7 +2193,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             // Target is exactly the same as current term
-                            Debug.Assert(term.Length == target.Length);
+                            Debugging.Assert(() => term.Length == target.Length);
                             if (termExists)
                             {
                                 //if (DEBUG) {
@@ -2217,8 +2215,8 @@ namespace Lucene.Net.Codecs
                         arc = outerInstance.index.GetFirstArc(arcs[0]);
 
                         // Empty string prefix must have an output (block) in the index!
-                        Debug.Assert(arc.IsFinal);
-                        Debug.Assert(arc.Output != null);
+                        Debugging.Assert(() => arc.IsFinal);
+                        Debugging.Assert(() => arc.Output != null);
 
                         //if (DEBUG) {
                         //System.out.println("    no seek state; push root frame");
@@ -2292,7 +2290,7 @@ namespace Lucene.Net.Codecs
                             term.Bytes[targetUpto] = (byte)targetLabel;
                             arc = nextArc;
                             // Aggregate output as we go:
-                            Debug.Assert(arc.Output != null);
+                            Debugging.Assert(() => arc.Output != null);
                             if (arc.Output != outerInstance.outerInstance.NO_OUTPUT)
                             {
                                 output = outerInstance.outerInstance.fstOutputs.Add(output, arc.Output);
@@ -2362,7 +2360,7 @@ namespace Lucene.Net.Codecs
                 //        while (true)
                 //        {
                 //            Frame f = GetFrame(ord);
-                //            Debug.Assert(f != null);
+                //            Debugging.Assert(f != null);
                 //            BytesRef prefix = new BytesRef(term.Bytes, 0, f.Prefix);
                 //            if (f.NextEnt == -1)
                 //            {
@@ -2374,7 +2372,7 @@ namespace Lucene.Net.Codecs
                 //            }
                 //            if (OuterInstance.Index != null)
                 //            {
-                //                Debug.Assert(!isSeekFrame || f.Arc != null, "isSeekFrame=" + isSeekFrame + " f.arc=" + f.Arc);
+                //                Debugging.Assert(!isSeekFrame || f.Arc != null, "isSeekFrame=" + isSeekFrame + " f.arc=" + f.Arc);
                 //                if (f.Prefix > 0 && isSeekFrame && f.Arc.Label != (term.Bytes[f.Prefix - 1] & 0xFF))
                 //                {
                 //                    @out.println("      broken seek state: arc.label=" + (char)f.Arc.Label + " vs term byte=" + (char)(term.Bytes[f.Prefix - 1] & 0xFF));
@@ -2425,7 +2423,7 @@ namespace Lucene.Net.Codecs
                         {
                             arc = outerInstance.index.GetFirstArc(arcs[0]);
                             // Empty string prefix must have an output in the index!
-                            Debug.Assert(arc.IsFinal);
+                            Debugging.Assert(() => arc.IsFinal);
                         }
                         else
                         {
@@ -2437,7 +2435,7 @@ namespace Lucene.Net.Codecs
 
                     targetBeforeCurrentLength = currentFrame.ord;
 
-                    Debug.Assert(!eof);
+                    Debugging.Assert(() => !eof);
                     //if (DEBUG) {
                     //System.out.println("\nBTTR.next seg=" + segment + " term=" + brToString(term) + " termExists?=" + termExists + " field=" + fieldInfo.name + " termBlockOrd=" + currentFrame.state.termBlockOrd + " validIndexPrefix=" + validIndexPrefix);
                     //printSeekState();
@@ -2453,7 +2451,7 @@ namespace Lucene.Net.Codecs
                         // works properly:
                         //if (DEBUG) System.out.println("  re-seek to pending term=" + term.utf8ToString() + " " + term);
                         bool result = SeekExact(term);
-                        Debug.Assert(result);
+                        Debugging.Assert(() => result);
                     }
 
                     // Pop finished blocks
@@ -2469,7 +2467,7 @@ namespace Lucene.Net.Codecs
                             if (currentFrame.ord == 0)
                             {
                                 //if (DEBUG) System.out.println("  return null");
-                                Debug.Assert(SetEOF());
+                                Debugging.Assert(() => SetEOF());
                                 term.Length = 0;
                                 validIndexPrefix = 0;
                                 currentFrame.Rewind();
@@ -2523,7 +2521,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debug.Assert(!eof);
+                        Debugging.Assert(() => !eof);
                         return term;
                     }
                 }
@@ -2532,7 +2530,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debug.Assert(!eof);
+                        Debugging.Assert(() => !eof);
                         //if (DEBUG) System.out.println("BTR.docFreq");
                         currentFrame.DecodeMetaData();
                         //if (DEBUG) System.out.println("  return " + currentFrame.state.docFreq);
@@ -2544,7 +2542,7 @@ namespace Lucene.Net.Codecs
                 {
                     get
                     {
-                        Debug.Assert(!eof);
+                        Debugging.Assert(() => !eof);
                         currentFrame.DecodeMetaData();
                         return currentFrame.state.TotalTermFreq;
                     }
@@ -2552,7 +2550,7 @@ namespace Lucene.Net.Codecs
 
                 public override DocsEnum Docs(IBits skipDocs, DocsEnum reuse, DocsFlags flags)
                 {
-                    Debug.Assert(!eof);
+                    Debugging.Assert(() => !eof);
                     //if (DEBUG) {
                     //System.out.println("BTTR.docs seg=" + segment);
                     //}
@@ -2571,7 +2569,7 @@ namespace Lucene.Net.Codecs
                         return null;
                     }
 
-                    Debug.Assert(!eof);
+                    Debugging.Assert(() => !eof);
                     currentFrame.DecodeMetaData();
                     return outerInstance.outerInstance.postingsReader.DocsAndPositions(outerInstance.fieldInfo, currentFrame.state, skipDocs, reuse, flags);
                 }
@@ -2581,15 +2579,15 @@ namespace Lucene.Net.Codecs
                     // if (DEBUG) {
                     //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
                     // }
-                    Debug.Assert(ClearEOF());
+                    Debugging.Assert(() => ClearEOF());
                     if (target.CompareTo(term) != 0 || !termExists)
                     {
-                        Debug.Assert(otherState != null && otherState is BlockTermState);
+                        Debugging.Assert(() => otherState != null && otherState is BlockTermState);
                         currentFrame = staticFrame;
                         currentFrame.state.CopyFrom(otherState);
                         term.CopyBytes(target);
                         currentFrame.metaDataUpto = currentFrame.TermBlockOrd;
-                        Debug.Assert(currentFrame.metaDataUpto > 0);
+                        Debugging.Assert(() => currentFrame.metaDataUpto > 0);
                         validIndexPrefix = 0;
                     }
                     else
@@ -2602,7 +2600,7 @@ namespace Lucene.Net.Codecs
 
                 public override TermState GetTermState()
                 {
-                    Debug.Assert(!eof);
+                    Debugging.Assert(() => !eof);
                     currentFrame.DecodeMetaData();
                     TermState ts = (TermState)currentFrame.state.Clone();
                     //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
@@ -2734,7 +2732,7 @@ namespace Lucene.Net.Codecs
                         //if (DEBUG) {
                         //System.out.println("    loadNextFloorBlock fp=" + fp + " fpEnd=" + fpEnd);
                         //}
-                        Debug.Assert(arc == null || isFloor, "arc=" + arc + " isFloor=" + isFloor);
+                        Debugging.Assert(() => arc == null || isFloor, () => "arc=" + arc + " isFloor=" + isFloor);
                         fp = fpEnd;
                         nextEnt = -1;
                         LoadBlock();
@@ -2768,9 +2766,9 @@ namespace Lucene.Net.Codecs
                         outerInstance.@in.Seek(fp);
                         int code = outerInstance.@in.ReadVInt32();
                         entCount = (int)((uint)code >> 1);
-                        Debug.Assert(entCount > 0);
+                        Debugging.Assert(() => entCount > 0);
                         isLastInFloor = (code & 1) != 0;
-                        Debug.Assert(arc == null || (isLastInFloor || isFloor));
+                        Debugging.Assert(() => arc == null || (isLastInFloor || isFloor));
 
                         // TODO: if suffixes were stored in random-access
                         // array structure, then we could do binary search
@@ -2891,7 +2889,7 @@ namespace Lucene.Net.Codecs
                     public bool NextLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debug.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         suffix = suffixesReader.ReadVInt32();
                         startBytePos = suffixesReader.Position;
@@ -2909,7 +2907,7 @@ namespace Lucene.Net.Codecs
                     public bool NextNonLeaf()
                     {
                         //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
-                        Debug.Assert(nextEnt != -1 && nextEnt < entCount, "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
+                        Debugging.Assert(() => nextEnt != -1 && nextEnt < entCount, () => "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp);
                         nextEnt++;
                         int code = suffixesReader.ReadVInt32();
                         suffix = (int)((uint)code >> 1);
@@ -2968,7 +2966,7 @@ namespace Lucene.Net.Codecs
                             return;
                         }
 
-                        Debug.Assert(numFollowFloorBlocks != 0);
+                        Debugging.Assert(() => numFollowFloorBlocks != 0);
 
                         long newFP = fpOrig;
                         while (true)
@@ -3028,7 +3026,7 @@ namespace Lucene.Net.Codecs
                         // lazily catch up on metadata decode:
                         int limit = TermBlockOrd;
                         bool absolute = metaDataUpto == 0;
-                        Debug.Assert(limit > 0);
+                        Debugging.Assert(() => limit > 0);
 
                         // TODO: better API would be "jump straight to term=N"???
                         while (metaDataUpto < limit)
@@ -3084,7 +3082,7 @@ namespace Lucene.Net.Codecs
                     /// </summary>
                     public void ScanToSubBlock(long subFP)
                     {
-                        Debug.Assert(!isLeafBlock);
+                        Debugging.Assert(() => !isLeafBlock);
                         //if (DEBUG) System.out.println("  scanToSubBlock fp=" + fp + " subFP=" + subFP + " entCount=" + entCount + " lastSubFP=" + lastSubFP);
                         //assert nextEnt == 0;
                         if (lastSubFP == subFP)
@@ -3092,12 +3090,12 @@ namespace Lucene.Net.Codecs
                             //if (DEBUG) System.out.println("    already positioned");
                             return;
                         }
-                        Debug.Assert(subFP < fp, "fp=" + fp + " subFP=" + subFP);
+                        Debugging.Assert(() => subFP < fp, () => "fp=" + fp + " subFP=" + subFP);
                         long targetSubCode = fp - subFP;
                         //if (DEBUG) System.out.println("    targetSubCode=" + targetSubCode);
                         while (true)
                         {
-                            Debug.Assert(nextEnt < entCount);
+                            Debugging.Assert(() => nextEnt < entCount);
                             nextEnt++;
                             int code = suffixesReader.ReadVInt32();
                             suffixesReader.SkipBytes(isLeafBlock ? code : (int)((uint)code >> 1));
@@ -3136,7 +3134,7 @@ namespace Lucene.Net.Codecs
                     {
                         // if (DEBUG) System.out.println("    scanToTermLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        Debug.Assert(nextEnt != -1);
+                        Debugging.Assert(() => nextEnt != -1);
 
                         outerInstance.termExists = true;
                         subCode = 0;
@@ -3150,7 +3148,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        Debug.Assert(PrefixMatches(target));
+                        Debugging.Assert(() => PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3189,7 +3187,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    Debug.Assert(targetPos == targetLimit);
+                                    Debugging.Assert(() => targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3245,7 +3243,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    Debug.Assert(outerInstance.termExists);
+                                    Debugging.Assert(() => outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
@@ -3282,7 +3280,7 @@ namespace Lucene.Net.Codecs
                     {
                         //if (DEBUG) System.out.println("    scanToTermNonLeaf: block fp=" + fp + " prefix=" + prefix + " nextEnt=" + nextEnt + " (of " + entCount + ") target=" + brToString(target) + " term=" + brToString(term));
 
-                        Debug.Assert(nextEnt != -1);
+                        Debugging.Assert(() => nextEnt != -1);
 
                         if (nextEnt == entCount)
                         {
@@ -3294,7 +3292,7 @@ namespace Lucene.Net.Codecs
                             return SeekStatus.END;
                         }
 
-                        Debug.Assert(PrefixMatches(target));
+                        Debugging.Assert(() => PrefixMatches(target));
 
                         // Loop over each entry (term or sub-block) in this block:
                         //nextTerm: while(nextEnt < entCount) {
@@ -3344,7 +3342,7 @@ namespace Lucene.Net.Codecs
                                 }
                                 else
                                 {
-                                    Debug.Assert(targetPos == targetLimit);
+                                    Debugging.Assert(() => targetPos == targetLimit);
                                     cmp = termLen - target.Length;
                                     stop = true;
                                 }
@@ -3401,7 +3399,7 @@ namespace Lucene.Net.Codecs
                                     // would have followed the index to this
                                     // sub-block from the start:
 
-                                    Debug.Assert(outerInstance.termExists);
+                                    Debugging.Assert(() => outerInstance.termExists);
                                     FillTerm();
                                     //if (DEBUG) System.out.println("        found!");
                                     return SeekStatus.FOUND;
diff --git a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
index 594937c..424bd4e 100644
--- a/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
+++ b/src/Lucene.Net/Codecs/BlockTreeTermsWriter.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util.Fst;
 using System;
@@ -258,9 +259,9 @@ namespace Lucene.Net.Codecs
 
             public FieldMetaData(FieldInfo fieldInfo, BytesRef rootCode, long numTerms, long indexStartFP, long sumTotalTermFreq, long sumDocFreq, int docCount, int longsSize)
             {
-                Debug.Assert(numTerms > 0);
+                Debugging.Assert(() => numTerms > 0);
                 this.FieldInfo = fieldInfo;
-                Debug.Assert(rootCode != null, "field=" + fieldInfo.Name + " numTerms=" + numTerms);
+                Debugging.Assert(() => rootCode != null, () => "field=" + fieldInfo.Name + " numTerms=" + numTerms);
                 this.RootCode = rootCode;
                 this.IndexStartFP = indexStartFP;
                 this.NumTerms = numTerms;
@@ -367,14 +368,14 @@ namespace Lucene.Net.Codecs
         {
             //DEBUG = field.name.Equals("id", StringComparison.Ordinal);
             //if (DEBUG) System.out.println("\nBTTW.addField seg=" + segment + " field=" + field.name);
-            Debug.Assert(currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
+            Debugging.Assert(() => currentField == null || currentField.Name.CompareToOrdinal(field.Name) < 0);
             currentField = field;
             return new TermsWriter(this, field);
         }
 
         internal static long EncodeOutput(long fp, bool hasTerms, bool isFloor)
         {
-            Debug.Assert(fp < (1L << 62));
+            Debugging.Assert(() => fp < (1L << 62));
             return (fp << 2) | (uint)(hasTerms ? OUTPUT_FLAG_HAS_TERMS : 0) | (uint)(isFloor ? OUTPUT_FLAG_IS_FLOOR : 0);
         }
 
@@ -480,11 +481,11 @@ namespace Lucene.Net.Codecs
                 // LUCENENET specific - we use a custom wrapper function to display floorBlocks, since
                 // it might contain garbage that cannot be converted into text. This is compiled out
                 // of the relese, though.
-                Debug.Assert(
-                    (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
-                    "isFloor=" + IsFloor + " floorBlocks=" + ToString(floorBlocks));
+                Debugging.Assert(
+                    () => (IsFloor && floorBlocks != null && floorBlocks.Count != 0) || (!IsFloor && floorBlocks == null),
+                    () => "isFloor=" + IsFloor + " floorBlocks=" + ToString(floorBlocks));
 
-                Debug.Assert(scratchBytes.GetFilePointer() == 0);
+                Debugging.Assert(() => scratchBytes.GetFilePointer() == 0);
 
                 // TODO: try writing the leading vLong in MSB order
                 // (opposite of what Lucene does today), for better
@@ -495,12 +496,12 @@ namespace Lucene.Net.Codecs
                     scratchBytes.WriteVInt32(floorBlocks.Count);
                     foreach (PendingBlock sub in floorBlocks)
                     {
-                        Debug.Assert(sub.FloorLeadByte != -1);
+                        Debugging.Assert(() => sub.FloorLeadByte != -1);
                         //if (DEBUG) {
                         //  System.out.println("    write floorLeadByte=" + Integer.toHexString(sub.floorLeadByte&0xff));
                         //}
                         scratchBytes.WriteByte((byte)(sbyte)sub.FloorLeadByte);
-                        Debug.Assert(sub.Fp > Fp);
+                        Debugging.Assert(() => sub.Fp > Fp);
                         scratchBytes.WriteVInt64((sub.Fp - Fp) << 1 | (uint)(sub.HasTerms ? 1 : 0));
                     }
                 }
@@ -508,7 +509,7 @@ namespace Lucene.Net.Codecs
                 ByteSequenceOutputs outputs = ByteSequenceOutputs.Singleton;
                 Builder<BytesRef> indexBuilder = new Builder<BytesRef>(FST.INPUT_TYPE.BYTE1, 0, 0, true, false, int.MaxValue, outputs, null, false, PackedInt32s.COMPACT, true, 15);
                 var bytes = new byte[(int)scratchBytes.GetFilePointer()];
-                Debug.Assert(bytes.Length > 0);
+                Debugging.Assert(() => bytes.Length > 0);
                 scratchBytes.WriteTo(bytes, 0);
                 indexBuilder.Add(Util.ToInt32sRef(Prefix, scratchIntsRef), new BytesRef(bytes, 0, bytes.Length));
                 scratchBytes.Reset();
@@ -727,8 +728,8 @@ namespace Lucene.Net.Codecs
                                 // Suffix is 0, ie prefix 'foo' and term is
                                 // 'foo' so the term has empty string suffix
                                 // in this block
-                                Debug.Assert(lastSuffixLeadLabel == -1);
-                                Debug.Assert(numSubs == 0);
+                                Debugging.Assert(() => lastSuffixLeadLabel == -1);
+                                Debugging.Assert(() => numSubs == 0);
                                 suffixLeadLabel = -1;
                             }
                             else
@@ -739,7 +740,7 @@ namespace Lucene.Net.Codecs
                         else
                         {
                             PendingBlock block = (PendingBlock)ent;
-                            Debug.Assert(block.Prefix.Length > prefixLength);
+                            Debugging.Assert(() => block.Prefix.Length > prefixLength);
                             suffixLeadLabel = block.Prefix.Bytes[block.Prefix.Offset + prefixLength] & 0xff;
                         }
 
@@ -860,7 +861,7 @@ namespace Lucene.Net.Codecs
                             //System.out.println("    = " + pendingCount);
                             pendingCount = 0;
 
-                            Debug.Assert(outerInstance.minItemsInBlock == 1 || subCount > 1, "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
+                            Debugging.Assert(() => outerInstance.minItemsInBlock == 1 || subCount > 1, () => "minItemsInBlock=" + outerInstance.minItemsInBlock + " subCount=" + subCount + " sub=" + sub + " of " + numSubs + " subTermCount=" + subTermCountSums[sub] + " subSubCount=" + subSubCounts[sub] + " depth=" + prefixLength);
                             subCount = 0;
                             startLabel = subBytes[sub + 1];
 
@@ -875,8 +876,8 @@ namespace Lucene.Net.Codecs
                                 // block.  NOTE that this may be too small (<
                                 // minItemsInBlock); need a true segmenter
                                 // here
-                                Debug.Assert(startLabel != -1);
-                                Debug.Assert(firstBlock != null);
+                                Debugging.Assert(() => startLabel != -1);
+                                Debugging.Assert(() => firstBlock != null);
                                 prevTerm.Int32s[prevTerm.Offset + prefixLength] = startLabel;
                                 //System.out.println("  final " + (numSubs-sub-1) + " subs");
                                 /*
@@ -896,7 +897,7 @@ namespace Lucene.Net.Codecs
 
                     prevTerm.Int32s[prevTerm.Offset + prefixLength] = savLabel;
 
-                    Debug.Assert(firstBlock != null);
+                    Debugging.Assert(() => firstBlock != null);
                     firstBlock.CompileIndex(floorBlocks, outerInstance.scratchBytes);
 
                     pending.Add(firstBlock);
@@ -925,11 +926,11 @@ namespace Lucene.Net.Codecs
             // block:
             private PendingBlock WriteBlock(Int32sRef prevTerm, int prefixLength, int indexPrefixLength, int startBackwards, int length, int futureTermCount, bool isFloor, int floorLeadByte, bool isLastInFloor)
             {
-                Debug.Assert(length > 0);
+                Debugging.Assert(() => length > 0);
 
                 int start = pending.Count - startBackwards;
 
-                Debug.Assert(start >= 0, "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
+                Debugging.Assert(() => start >= 0, () => "pending.Count=" + pending.Count + " startBackwards=" + startBackwards + " length=" + length);
 
                 IList<PendingEntry> slice = pending.SubList(start, start + length);
 
@@ -988,7 +989,7 @@ namespace Lucene.Net.Codecs
                     subIndices = null;
                     foreach (PendingEntry ent in slice)
                     {
-                        Debug.Assert(ent.IsTerm);
+                        Debugging.Assert(() => ent.IsTerm);
                         PendingTerm term = (PendingTerm)ent;
                         BlockTermState state = term.State;
                         int suffix = term.Term.Length - prefixLength;
@@ -1006,7 +1007,7 @@ namespace Lucene.Net.Codecs
                         statsWriter.WriteVInt32(state.DocFreq);
                         if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                         {
-                            Debug.Assert(state.TotalTermFreq >= state.DocFreq, state.TotalTermFreq + " vs " + state.DocFreq);
+                            Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq, () => state.TotalTermFreq + " vs " + state.DocFreq);
                             statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                         }
 
@@ -1014,7 +1015,7 @@ namespace Lucene.Net.Codecs
                         outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                         for (int pos = 0; pos < longsSize; pos++)
                         {
-                            Debug.Assert(longs[pos] >= 0);
+                            Debugging.Assert(() => longs[pos] >= 0);
                             metaWriter.WriteVInt64(longs[pos]);
                         }
                         bytesWriter.WriteTo(metaWriter);
@@ -1049,7 +1050,7 @@ namespace Lucene.Net.Codecs
                             statsWriter.WriteVInt32(state.DocFreq);
                             if (fieldInfo.IndexOptions != IndexOptions.DOCS_ONLY)
                             {
-                                Debug.Assert(state.TotalTermFreq >= state.DocFreq);
+                                Debugging.Assert(() => state.TotalTermFreq >= state.DocFreq);
                                 statsWriter.WriteVInt64(state.TotalTermFreq - state.DocFreq);
                             }
 
@@ -1065,7 +1066,7 @@ namespace Lucene.Net.Codecs
                             outerInstance.postingsWriter.EncodeTerm(longs, bytesWriter, fieldInfo, state, absolute);
                             for (int pos = 0; pos < longsSize; pos++)
                             {
-                                Debug.Assert(longs[pos] >= 0);
+                                Debugging.Assert(() => longs[pos] >= 0);
                                 metaWriter.WriteVInt64(longs[pos]);
                             }
                             bytesWriter.WriteTo(metaWriter);
@@ -1079,13 +1080,13 @@ namespace Lucene.Net.Codecs
                             PendingBlock block = (PendingBlock)ent;
                             int suffix = block.Prefix.Length - prefixLength;
 
-                            Debug.Assert(suffix > 0);
+                            Debugging.Assert(() => suffix > 0);
 
                             // For non-leaf block we borrow 1 bit to record
                             // if entry is term or sub-block
                             suffixWriter.WriteVInt32((suffix << 1) | 1);
                             suffixWriter.WriteBytes(block.Prefix.Bytes, prefixLength, suffix);
-                            Debug.Assert(block.Fp < startFP);
+                            Debugging.Assert(() => block.Fp < startFP);
 
                             // if (DEBUG) {
                             //   BytesRef suffixBytes = new BytesRef(suffix);
@@ -1099,7 +1100,7 @@ namespace Lucene.Net.Codecs
                         }
                     }
 
-                    Debug.Assert(subIndices.Count != 0);
+                    Debugging.Assert(() => subIndices.Count != 0);
                 }
 
                 // TODO: we could block-write the term suffix pointers;
@@ -1178,7 +1179,7 @@ namespace Lucene.Net.Codecs
 
             public override void FinishTerm(BytesRef text, TermStats stats)
             {
-                Debug.Assert(stats.DocFreq > 0);
+                Debugging.Assert(() => stats.DocFreq > 0);
                 //if (DEBUG) System.out.println("BTTW.finishTerm term=" + fieldInfo.name + ":" + toString(text) + " seg=" + segment + " df=" + stats.docFreq);
 
                 blockBuilder.Add(Util.ToInt32sRef(text, scratchIntsRef), noOutputs.NoOutput);
@@ -1200,10 +1201,10 @@ namespace Lucene.Net.Codecs
                     blockBuilder.Finish();
 
                     // We better have one final "root" block:
-                    Debug.Assert(pending.Count == 1 && !pending[0].IsTerm, "pending.size()=" + pending.Count + " pending=" + pending);
+                    Debugging.Assert(() => pending.Count == 1 && !pending[0].IsTerm, () => "pending.size()=" + pending.Count + " pending=" + pending);
                     PendingBlock root = (PendingBlock)pending[0];
-                    Debug.Assert(root.Prefix.Length == 0);
-                    Debug.Assert(root.Index.EmptyOutput != null);
+                    Debugging.Assert(() => root.Prefix.Length == 0);
+                    Debugging.Assert(() => root.Index.EmptyOutput != null);
 
                     this.sumTotalTermFreq = sumTotalTermFreq;
                     this.sumDocFreq = sumDocFreq;
@@ -1226,9 +1227,9 @@ namespace Lucene.Net.Codecs
                 }
                 else
                 {
-                    Debug.Assert(sumTotalTermFreq == 0 || fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY && sumTotalTermFreq == -1);
-                    Debug.Assert(sumDocFreq == 0);
-                    Debug.Assert(docCount == 0);
+                    Debugging.Assert(() => sumTotalTermFreq == 0 || fieldInfo.IndexOptions == IndexOptions.DOCS_ONLY && sumTotalTermFreq == -1);
+                    Debugging.Assert(() => sumDocFreq == 0);
+                    Debugging.Assert(() => docCount == 0);
                 }
             }
 
diff --git a/src/Lucene.Net/Codecs/CodecUtil.cs b/src/Lucene.Net/Codecs/CodecUtil.cs
index 8985fae..648b032 100644
--- a/src/Lucene.Net/Codecs/CodecUtil.cs
+++ b/src/Lucene.Net/Codecs/CodecUtil.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
@@ -267,7 +268,7 @@ namespace Lucene.Net.Codecs
             IndexInput clone = (IndexInput)input.Clone();
             clone.Seek(0);
             ChecksumIndexInput @in = new BufferedChecksumIndexInput(clone);
-            Debug.Assert(@in.GetFilePointer() == 0);
+            Debugging.Assert(() => @in.GetFilePointer() == 0);
             @in.Seek(@in.Length - FooterLength());
             return CheckFooter(@in);
         }
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
index d45adb3..05fd3e8 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -105,7 +106,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         private void WriteBlock()
         {
-            Debug.Assert(blockChunks > 0);
+            Debugging.Assert(() => blockChunks > 0);
             fieldsIndexOut.WriteVInt32(blockChunks);
 
             // The trick here is that we only store the difference from the average start
@@ -143,7 +144,7 @@ namespace Lucene.Net.Codecs.Compressing
             for (int i = 0; i < blockChunks; ++i)
             {
                 long delta = docBase - avgChunkDocs * i;
-                Debug.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
+                Debugging.Assert(() => PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
                 writer.Add(MoveSignToLowOrderBit(delta));
                 docBase += docBaseDeltas[i];
             }
@@ -178,7 +179,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 startPointer += startPointerDeltas[i];
                 long delta = startPointer - avgChunkSize * i;
-                Debug.Assert(PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
+                Debugging.Assert(() => PackedInt32s.BitsRequired(MoveSignToLowOrderBit(delta)) <= writer.BitsPerValue);
                 writer.Add(MoveSignToLowOrderBit(delta));
             }
             writer.Finish();
@@ -196,7 +197,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 firstStartPointer = maxStartPointer = startPointer;
             }
-            Debug.Assert(firstStartPointer > 0 && startPointer >= firstStartPointer);
+            Debugging.Assert(() => firstStartPointer > 0 && startPointer >= firstStartPointer);
 
             docBaseDeltas[blockChunks] = numDocs;
             startPointerDeltas[blockChunks] = startPointer - maxStartPointer;
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
index 130f2dc..46eb4f4 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Codecs.Lucene40;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -100,7 +101,7 @@ namespace Lucene.Net.Codecs.Compressing
                 indexStream = d.OpenChecksumInput(indexStreamFN, context);
                 string codecNameIdx = formatName + CompressingStoredFieldsWriter.CODEC_SFX_IDX;
                 version = CodecUtil.CheckHeader(indexStream, codecNameIdx, CompressingStoredFieldsWriter.VERSION_START, CompressingStoredFieldsWriter.VERSION_CURRENT);
-                Debug.Assert(CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
                 indexReader = new CompressingStoredFieldsIndexReader(indexStream, si);
 
                 long maxPointer = -1;
@@ -139,7 +140,7 @@ namespace Lucene.Net.Codecs.Compressing
                 {
                     throw new CorruptIndexException("Version mismatch between stored fields index and data: " + version + " != " + fieldsVersion);
                 }
-                Debug.Assert(CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
 
                 if (version >= CompressingStoredFieldsWriter.VERSION_BIG_CHUNKS)
                 {
@@ -332,8 +333,8 @@ namespace Lucene.Net.Codecs.Compressing
             DataInput documentInput;
             if (version >= CompressingStoredFieldsWriter.VERSION_BIG_CHUNKS && totalLength >= 2 * chunkSize)
             {
-                Debug.Assert(chunkSize > 0);
-                Debug.Assert(offset < chunkSize);
+                Debugging.Assert(() => chunkSize > 0);
+                Debugging.Assert(() => offset < chunkSize);
 
                 decompressor.Decompress(fieldsStream, chunkSize, offset, Math.Min(length, chunkSize - offset), bytes);
                 documentInput = new DataInputAnonymousInnerClassHelper(this, offset, length);
@@ -342,7 +343,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 BytesRef bytes = totalLength <= BUFFER_REUSE_THRESHOLD ? this.bytes : new BytesRef();
                 decompressor.Decompress(fieldsStream, totalLength, offset, length, bytes);
-                Debug.Assert(bytes.Length == length);
+                Debugging.Assert(() => bytes.Length == length);
                 documentInput = new ByteArrayDataInput(bytes.Bytes, bytes.Offset, bytes.Length);
             }
 
@@ -353,7 +354,7 @@ namespace Lucene.Net.Codecs.Compressing
                 FieldInfo fieldInfo = fieldInfos.FieldInfo(fieldNumber);
 
                 int bits = (int)(infoAndBits & CompressingStoredFieldsWriter.TYPE_MASK);
-                Debug.Assert(bits <= CompressingStoredFieldsWriter.NUMERIC_DOUBLE, "bits=" + bits.ToString("x"));
+                Debugging.Assert(() => bits <= CompressingStoredFieldsWriter.NUMERIC_DOUBLE, () => "bits=" + bits.ToString("x"));
 
                 switch (visitor.NeedsField(fieldInfo))
                 {
@@ -390,7 +391,7 @@ namespace Lucene.Net.Codecs.Compressing
 
             internal virtual void FillBuffer()
             {
-                Debug.Assert(decompressed <= length);
+                Debugging.Assert(() => decompressed <= length);
                 if (decompressed == length)
                 {
                     throw new Exception();
@@ -488,7 +489,7 @@ namespace Lucene.Net.Codecs.Compressing
             /// </summary>
             internal void Next(int doc)
             {
-                Debug.Assert(doc >= this.docBase + this.chunkDocs, doc + " " + this.docBase + " " + this.chunkDocs);
+                Debugging.Assert(() => doc >= this.docBase + this.chunkDocs, () => doc + " " + this.docBase + " " + this.chunkDocs);
                 fieldsStream.Seek(outerInstance.indexReader.GetStartPointer(doc));
 
                 int docBase = fieldsStream.ReadVInt32();
@@ -587,7 +588,7 @@ namespace Lucene.Net.Codecs.Compressing
             /// </summary>
             internal void CopyCompressedData(DataOutput @out)
             {
-                Debug.Assert(outerInstance.Version == CompressingStoredFieldsWriter.VERSION_CURRENT);
+                Debugging.Assert(() => outerInstance.Version == CompressingStoredFieldsWriter.VERSION_CURRENT);
                 long chunkEnd = docBase + chunkDocs == outerInstance.numDocs ? outerInstance.maxPointer : outerInstance.indexReader.GetStartPointer(docBase + chunkDocs);
                 @out.CopyBytes(fieldsStream, chunkEnd - fieldsStream.GetFilePointer());
             }
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs
index 587df35..b9a3900 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs
@@ -1,5 +1,6 @@
 using J2N;
 using Lucene.Net.Codecs.Lucene40;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
@@ -90,7 +91,7 @@ namespace Lucene.Net.Codecs.Compressing
         /// Sole constructor. </summary>
         public CompressingStoredFieldsWriter(Directory directory, SegmentInfo si, string segmentSuffix, IOContext context, string formatName, CompressionMode compressionMode, int chunkSize)
         {
-            Debug.Assert(directory != null);
+            Debugging.Assert(() => directory != null);
             this.directory = directory;
             this.segment = si.Name;
             this.segmentSuffix = segmentSuffix;
@@ -113,8 +114,8 @@ namespace Lucene.Net.Codecs.Compressing
                 string codecNameDat = formatName + CODEC_SFX_DAT;
                 CodecUtil.WriteHeader(indexStream, codecNameIdx, VERSION_CURRENT);
                 CodecUtil.WriteHeader(fieldsStream, codecNameDat, VERSION_CURRENT);
-                Debug.Assert(CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
-                Debug.Assert(CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameDat) == fieldsStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
 
                 indexWriter = new CompressingStoredFieldsIndexWriter(indexStream);
                 indexStream = null;
@@ -177,7 +178,7 @@ namespace Lucene.Net.Codecs.Compressing
         /// </summary>
         private static void SaveInt32s(int[] values, int length, DataOutput @out)
         {
-            Debug.Assert(length > 0);
+            Debugging.Assert(() => length > 0);
             if (length == 1)
             {
                 @out.WriteVInt32(values[0]);
@@ -245,7 +246,7 @@ namespace Lucene.Net.Codecs.Compressing
             for (int i = numBufferedDocs - 1; i > 0; --i)
             {
                 lengths[i] = endOffsets[i] - endOffsets[i - 1];
-                Debug.Assert(lengths[i] >= 0);
+                Debugging.Assert(() => lengths[i] >= 0);
             }
             WriteHeader(docBase, numBufferedDocs, numStoredFields, lengths);
 
@@ -373,7 +374,7 @@ namespace Lucene.Net.Codecs.Compressing
             }
             else
             {
-                Debug.Assert(bufferedDocs.Length == 0);
+                Debugging.Assert(() => bufferedDocs.Length == 0);
             }
             if (docBase != numDocs)
             {
@@ -381,7 +382,7 @@ namespace Lucene.Net.Codecs.Compressing
             }
             indexWriter.Finish(numDocs, fieldsStream.GetFilePointer());
             CodecUtil.WriteFooter(fieldsStream);
-            Debug.Assert(bufferedDocs.Length == 0);
+            Debugging.Assert(() => bufferedDocs.Length == 0);
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
@@ -442,7 +443,7 @@ namespace Lucene.Net.Codecs.Compressing
 
                             if (numBufferedDocs == 0 && startOffsets[it.chunkDocs - 1] < chunkSize && startOffsets[it.chunkDocs - 1] + it.lengths[it.chunkDocs - 1] >= chunkSize && NextDeletedDoc(it.docBase, liveDocs, it.docBase + it.chunkDocs) == it.docBase + it.chunkDocs) // no deletion in the chunk -  chunk is large enough -  chunk is small enough -  starting a new chunk
                             {
-                                Debug.Assert(docID == it.docBase);
+                                Debugging.Assert(() => docID == it.docBase);
 
                                 // no need to decompress, just copy data
                                 indexWriter.WriteIndex(it.chunkDocs, fieldsStream.GetFilePointer());
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
index 1032ebe..c8e4a25 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
@@ -77,7 +78,7 @@ namespace Lucene.Net.Codecs.Compressing
                 indexStream = d.OpenChecksumInput(indexStreamFN, context);
                 string codecNameIdx = formatName + CompressingTermVectorsWriter.CODEC_SFX_IDX;
                 version = CodecUtil.CheckHeader(indexStream, codecNameIdx, CompressingTermVectorsWriter.VERSION_START, CompressingTermVectorsWriter.VERSION_CURRENT);
-                Debug.Assert(CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
                 indexReader = new CompressingStoredFieldsIndexReader(indexStream, si);
 
                 if (version >= CompressingTermVectorsWriter.VERSION_CHECKSUM)
@@ -103,7 +104,7 @@ namespace Lucene.Net.Codecs.Compressing
                 {
                     throw new Exception("Version mismatch between stored fields index and data: " + version + " != " + version2);
                 }
-                Debug.Assert(CodecUtil.HeaderLength(codecNameDat) == vectorsStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameDat) == vectorsStream.GetFilePointer());
 
                 packedIntsVersion = vectorsStream.ReadVInt32();
                 chunkSize = vectorsStream.ReadVInt32();
@@ -215,7 +216,7 @@ namespace Lucene.Net.Codecs.Compressing
             int[] fieldNums;
             {
                 int token = vectorsStream.ReadByte() & 0xFF;
-                Debug.Assert(token != 0); // means no term vectors, cannot happen since we checked for numFields == 0
+                Debugging.Assert(() => token != 0); // means no term vectors, cannot happen since we checked for numFields == 0
                 int bitsPerFieldNum = token & 0x1F;
                 int totalDistinctFields = (int)((uint)token >> 5);
                 if (totalDistinctFields == 0x07)
@@ -245,7 +246,7 @@ namespace Lucene.Net.Codecs.Compressing
                         for (int i = 0; i < totalFields; ++i)
                         {
                             int fieldNumOff = (int)allFieldNumOffs.Get(i);
-                            Debug.Assert(fieldNumOff >= 0 && fieldNumOff < fieldNums.Length);
+                            Debugging.Assert(() => fieldNumOff >= 0 && fieldNumOff < fieldNums.Length);
                             int fgs = (int)fieldFlags.Get(fieldNumOff);
                             f.Set(i, fgs);
                         }
@@ -382,7 +383,7 @@ namespace Lucene.Net.Codecs.Compressing
                         totalPayloads += freq;
                     }
                 }
-                Debug.Assert(i != totalFields - 1 || termIndex == totalTerms, termIndex + " " + totalTerms);
+                Debugging.Assert(() => i != totalFields - 1 || termIndex == totalTerms, () => termIndex + " " + totalTerms);
             }
 
             int[][] positionIndex = PositionIndex(skip, numFields, numTerms, termFreqs);
@@ -515,7 +516,7 @@ namespace Lucene.Net.Codecs.Compressing
                                 ++posIdx;
                             }
                         }
-                        Debug.Assert(posIdx == totalFreq);
+                        Debugging.Assert(() => posIdx == totalFreq);
                     }
                     termIndex += termCount;
                 }
@@ -537,7 +538,7 @@ namespace Lucene.Net.Codecs.Compressing
                     }
                     termIndex += termCount;
                 }
-                Debug.Assert(termIndex == totalTerms, termIndex + " " + totalTerms);
+                Debugging.Assert(() => termIndex == totalTerms, () => termIndex + " " + totalTerms);
             }
 
             // decompress data
@@ -576,7 +577,7 @@ namespace Lucene.Net.Codecs.Compressing
                 }
             }
 
-            Debug.Assert(Sum(fieldLengths) == docLen, Sum(fieldLengths) + " != " + docLen);
+            Debugging.Assert(() => Sum(fieldLengths) == docLen, () => Sum(fieldLengths) + " != " + docLen);
 
             return new TVFields(this, fieldNums, FieldFlags, fieldNumOffs, fieldNumTerms, fieldLengths, prefixLengths, suffixLengths, fieldTermFreqs, positionIndex, positions, startOffsets, lengths, payloadBytes, payloadIndex, suffixBytes);
         }
@@ -731,7 +732,7 @@ namespace Lucene.Net.Codecs.Compressing
                         break;
                     }
                 }
-                Debug.Assert(fieldLen >= 0);
+                Debugging.Assert(() => fieldLen >= 0);
                 return new TVTerms(outerInstance, numTerms[idx], fieldFlags[idx], prefixLengths[idx], suffixLengths[idx], termFreqs[idx], positionIndex[idx], positions[idx], startOffsets[idx], lengths[idx], payloadIndex[idx], payloadBytes, new BytesRef(suffixBytes.Bytes, suffixBytes.Offset + fieldOff, fieldLen));
             }
 
@@ -842,7 +843,7 @@ namespace Lucene.Net.Codecs.Compressing
                 }
                 else
                 {
-                    Debug.Assert(ord < numTerms);
+                    Debugging.Assert(() => ord < numTerms);
                     ++ord;
                 }
 
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
index 9252c16..4c2d15a 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
@@ -244,7 +245,7 @@ namespace Lucene.Net.Codecs.Compressing
         /// Sole constructor. </summary>
         public CompressingTermVectorsWriter(Directory directory, SegmentInfo si, string segmentSuffix, IOContext context, string formatName, CompressionMode compressionMode, int chunkSize)
         {
-            Debug.Assert(directory != null);
+            Debugging.Assert(() => directory != null);
             this.directory = directory;
             this.segment = si.Name;
             this.segmentSuffix = segmentSuffix;
@@ -268,8 +269,8 @@ namespace Lucene.Net.Codecs.Compressing
                 string codecNameDat = formatName + CODEC_SFX_DAT;
                 CodecUtil.WriteHeader(indexStream, codecNameIdx, VERSION_CURRENT);
                 CodecUtil.WriteHeader(vectorsStream, codecNameDat, VERSION_CURRENT);
-                Debug.Assert(CodecUtil.HeaderLength(codecNameDat) == vectorsStream.GetFilePointer());
-                Debug.Assert(CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameDat) == vectorsStream.GetFilePointer());
+                Debugging.Assert(() => CodecUtil.HeaderLength(codecNameIdx) == indexStream.GetFilePointer());
 
                 indexWriter = new CompressingStoredFieldsIndexWriter(indexStream);
                 indexStream = null;
@@ -350,7 +351,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override void StartTerm(BytesRef term, int freq)
         {
-            Debug.Assert(freq >= 1);
+            Debugging.Assert(() => freq >= 1);
             int prefix = StringHelper.BytesDifference(lastTerm, term);
             curField.AddTerm(freq, prefix, term.Length - prefix);
             termSuffixes.WriteBytes(term.Bytes, term.Offset + prefix, term.Length - prefix);
@@ -366,7 +367,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override void AddPosition(int position, int startOffset, int endOffset, BytesRef payload)
         {
-            Debug.Assert(curField.flags != 0);
+            Debugging.Assert(() => curField.flags != 0);
             curField.AddPosition(position, startOffset, endOffset - startOffset, payload == null ? 0 : payload.Length);
             if (curField.hasPayloads && payload != null)
             {
@@ -383,7 +384,7 @@ namespace Lucene.Net.Codecs.Compressing
         private void Flush()
         {
             int chunkDocs = pendingDocs.Count;
-            Debug.Assert(chunkDocs > 0, chunkDocs.ToString());
+            Debugging.Assert(() => chunkDocs > 0, chunkDocs.ToString);
 
             // write the index file
             indexWriter.WriteIndex(chunkDocs, vectorsStream.GetFilePointer());
@@ -463,7 +464,7 @@ namespace Lucene.Net.Codecs.Compressing
             }
 
             int numDistinctFields = fieldNums.Count;
-            Debug.Assert(numDistinctFields > 0);
+            Debugging.Assert(() => numDistinctFields > 0);
             int bitsRequired = PackedInt32s.BitsRequired(fieldNums.Max);
             int token = (Math.Min(numDistinctFields - 1, 0x07) << 5) | bitsRequired;
             vectorsStream.WriteByte((byte)(sbyte)token);
@@ -495,7 +496,7 @@ namespace Lucene.Net.Codecs.Compressing
                 foreach (FieldData fd in dd.fields)
                 {
                     int fieldNumIndex = Array.BinarySearch(fieldNums, fd.fieldNum);
-                    Debug.Assert(fieldNumIndex >= 0);
+                    Debugging.Assert(() => fieldNumIndex >= 0);
                     writer.Add(fieldNumIndex);
                 }
             }
@@ -515,7 +516,7 @@ namespace Lucene.Net.Codecs.Compressing
                 foreach (FieldData fd in dd.fields)
                 {
                     int fieldNumOff = Array.BinarySearch(fieldNums, fd.fieldNum);
-                    Debug.Assert(fieldNumOff >= 0);
+                    Debugging.Assert(() => fieldNumOff >= 0);
                     if (fieldFlags[fieldNumOff] == -1)
                     {
                         fieldFlags[fieldNumOff] = fd.flags;
@@ -537,10 +538,10 @@ namespace Lucene.Net.Codecs.Compressing
                 PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, fieldFlags.Length, FLAGS_BITS, 1);
                 foreach (int flags in fieldFlags)
                 {
-                    Debug.Assert(flags >= 0);
+                    Debugging.Assert(() => flags >= 0);
                     writer.Add(flags);
                 }
-                Debug.Assert(writer.Ord == fieldFlags.Length - 1);
+                Debugging.Assert(() => writer.Ord == fieldFlags.Length - 1);
                 writer.Finish();
             }
             else
@@ -555,7 +556,7 @@ namespace Lucene.Net.Codecs.Compressing
                         writer.Add(fd.flags);
                     }
                 }
-                Debug.Assert(writer.Ord == totalFields - 1);
+                Debugging.Assert(() => writer.Ord == totalFields - 1);
                 writer.Finish();
             }
         }
@@ -580,7 +581,7 @@ namespace Lucene.Net.Codecs.Compressing
                     writer.Add(fd.numTerms);
                 }
             }
-            Debug.Assert(writer.Ord == totalFields - 1);
+            Debugging.Assert(() => writer.Ord == totalFields - 1);
             writer.Finish();
         }
 
@@ -648,7 +649,7 @@ namespace Lucene.Net.Codecs.Compressing
                                 previousPosition = position;
                             }
                         }
-                        Debug.Assert(pos == fd.totalPositions);
+                        Debugging.Assert(() => pos == fd.totalPositions);
                     }
                 }
             }
@@ -684,7 +685,7 @@ namespace Lucene.Net.Codecs.Compressing
                                 ++pos;
                             }
                         }
-                        Debug.Assert(pos == fd.totalPositions);
+                        Debugging.Assert(() => pos == fd.totalPositions);
                     }
                 }
             }
@@ -752,7 +753,7 @@ namespace Lucene.Net.Codecs.Compressing
                                 writer.Add(lengthsBuf[fd.offStart + pos++] - fd.prefixLengths[i] - fd.suffixLengths[i]);
                             }
                         }
-                        Debug.Assert(pos == fd.totalPositions);
+                        Debugging.Assert(() => pos == fd.totalPositions);
                     }
                 }
             }
@@ -796,8 +797,8 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override void AddProx(int numProx, DataInput positions, DataInput offsets)
         {
-            Debug.Assert((curField.hasPositions) == (positions != null));
-            Debug.Assert((curField.hasOffsets) == (offsets != null));
+            Debugging.Assert(() => (curField.hasPositions) == (positions != null));
+            Debugging.Assert(() => (curField.hasOffsets) == (offsets != null));
 
             if (curField.hasPositions)
             {
@@ -919,7 +920,7 @@ namespace Lucene.Net.Codecs.Compressing
                         {
                             int docBase = vectorsStream.ReadVInt32();
                             int chunkDocs = vectorsStream.ReadVInt32();
-                            Debug.Assert(docBase + chunkDocs <= matchingSegmentReader.MaxDoc);
+                            Debugging.Assert(() => docBase + chunkDocs <= matchingSegmentReader.MaxDoc);
                             if (docBase + chunkDocs < matchingSegmentReader.MaxDoc && NextDeletedDoc(docBase, liveDocs, docBase + chunkDocs) == docBase + chunkDocs)
                             {
                                 long chunkEnd = index.GetStartPointer(docBase + chunkDocs);
diff --git a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
index 976c729..5ca2019 100644
--- a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
+++ b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
@@ -151,7 +152,7 @@ namespace Lucene.Net.Codecs.Compressing
 
             public override void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes)
             {
-                Debug.Assert(offset + length <= originalLength);
+                Debugging.Assert(() => offset + length <= originalLength);
                 // add 7 padding bytes, this is not necessary but can help decompression run faster
                 if (bytes.Bytes.Length < originalLength + 7)
                 {
@@ -211,7 +212,7 @@ namespace Lucene.Net.Codecs.Compressing
 
             public override void Decompress(DataInput input, int originalLength, int offset, int length, BytesRef bytes)
             {
-                Debug.Assert(offset + length <= originalLength);
+                Debugging.Assert(() => offset + length <= originalLength);
                 if (length == 0)
                 {
                     bytes.Length = 0;
@@ -272,7 +273,7 @@ namespace Lucene.Net.Codecs.Compressing
 
                 if (resultArray.Length == 0)
                 {
-                    Debug.Assert(len == 0, len.ToString());
+                    Debugging.Assert(() => len == 0, len.ToString);
                     output.WriteVInt32(0);
                     return;
                 }
diff --git a/src/Lucene.Net/Codecs/Compressing/LZ4.cs b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
index 878ecdc..cf1c493 100644
--- a/src/Lucene.Net/Codecs/Compressing/LZ4.cs
+++ b/src/Lucene.Net/Codecs/Compressing/LZ4.cs
@@ -1,4 +1,5 @@
 using J2N.Numerics;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -75,7 +76,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         private static int CommonBytes(byte[] b, int o1, int o2, int limit)
         {
-            Debug.Assert(o1 < o2);
+            Debugging.Assert(() => o1 < o2);
             int count = 0;
             while (o2 < limit && b[o1++] == b[o2++])
             {
@@ -134,7 +135,7 @@ namespace Lucene.Net.Codecs.Compressing
                 var byte1 = compressed.ReadByte();
                 var byte2 = compressed.ReadByte();
                 int matchDec = (byte1 & 0xFF) | ((byte2 & 0xFF) << 8);
-                Debug.Assert(matchDec > 0);
+                Debugging.Assert(() => matchDec > 0);
 
                 int matchLen = token & 0x0F;
                 if (matchLen == 0x0F)
@@ -202,14 +203,14 @@ namespace Lucene.Net.Codecs.Compressing
         private static void EncodeSequence(byte[] bytes, int anchor, int matchRef, int matchOff, int matchLen, DataOutput @out)
         {
             int literalLen = matchOff - anchor;
-            Debug.Assert(matchLen >= 4);
+            Debugging.Assert(() => matchLen >= 4);
             // encode token
             int token = (Math.Min(literalLen, 0x0F) << 4) | Math.Min(matchLen - 4, 0x0F);
             EncodeLiterals(bytes, token, anchor, literalLen, @out);
 
             // encode match dec
             int matchDec = matchOff - matchRef;
-            Debug.Assert(matchDec > 0 && matchDec < 1 << 16);
+            Debugging.Assert(() => matchDec > 0 && matchDec < 1 << 16);
             @out.WriteByte((byte)(sbyte)matchDec);
             @out.WriteByte((byte)(sbyte)((int)((uint)matchDec >> 8)));
 
@@ -274,7 +275,7 @@ namespace Lucene.Net.Codecs.Compressing
                         int v = ReadInt32(bytes, off);
                         int h = Hash(v, hashLog);
                         @ref = @base + (int)hashTable.Get(h);
-                        Debug.Assert(PackedInt32s.BitsRequired(off - @base) <= hashTable.BitsPerValue);
+                        Debugging.Assert(() => PackedInt32s.BitsRequired(off - @base) <= hashTable.BitsPerValue);
                         hashTable.Set(h, off - @base);
                         if (off - @ref < MAX_DISTANCE && ReadInt32(bytes, @ref) == v)
                         {
@@ -296,7 +297,7 @@ namespace Lucene.Net.Codecs.Compressing
 
             // last literals
             int literalLen = end - anchor;
-            Debug.Assert(literalLen >= LAST_LITERALS || literalLen == len);
+            Debugging.Assert(() => literalLen >= LAST_LITERALS || literalLen == len);
             EncodeLastLiterals(bytes, anchor, end - anchor, @out);
         }
 
@@ -364,7 +365,7 @@ namespace Lucene.Net.Codecs.Compressing
                 int v = ReadInt32(bytes, off);
                 int h = HashHC(v);
                 int delta = off - hashTable[h];
-                Debug.Assert(delta > 0, delta.ToString());
+                Debugging.Assert(() => delta > 0, delta.ToString);
                 if (delta >= MAX_DISTANCE)
                 {
                     delta = MAX_DISTANCE - 1;
@@ -512,7 +513,7 @@ namespace Lucene.Net.Codecs.Compressing
 
                 while (true)
                 {
-                    Debug.Assert(match1.start >= anchor);
+                    Debugging.Assert(() => match1.start >= anchor);
                     if (match1.End() >= mfLimit || !ht.InsertAndFindWiderMatch(src, match1.End() - 2, match1.start + 1, matchLimit, match1.len, match2))
                     {
                         // no better match
@@ -528,7 +529,7 @@ namespace Lucene.Net.Codecs.Compressing
                             CopyTo(match0, match1);
                         }
                     }
-                    Debug.Assert(match2.start > match1.start);
+                    Debugging.Assert(() => match2.start > match1.start);
 
                     if (match2.start - match1.start < 3) // First Match too small : removed
                     {
diff --git a/src/Lucene.Net/Codecs/DocValuesConsumer.cs b/src/Lucene.Net/Codecs/DocValuesConsumer.cs
index 8282d03..8cbd4a5 100644
--- a/src/Lucene.Net/Codecs/DocValuesConsumer.cs
+++ b/src/Lucene.Net/Codecs/DocValuesConsumer.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -485,7 +486,7 @@ namespace Lucene.Net.Codecs
 
                 if (currentLiveDocs == null || currentLiveDocs.Get(docIDUpto))
                 {
-                    Debug.Assert(docIDUpto < currentReader.MaxDoc);
+                    Debugging.Assert(() => docIDUpto < currentReader.MaxDoc);
                     SortedSetDocValues dv = dvs[readerUpto];
                     dv.SetDocument(docIDUpto);
                     ordUpto = ordLength = 0;
@@ -515,7 +516,7 @@ namespace Lucene.Net.Codecs
             internal BitsFilteredTermsEnum(TermsEnum @in, Int64BitSet liveTerms)
                 : base(@in, false)
             {
-                Debug.Assert(liveTerms != null);
+                Debugging.Assert(() => liveTerms != null);
                 this.liveTerms = liveTerms;
             }
 
diff --git a/src/Lucene.Net/Codecs/FieldsConsumer.cs b/src/Lucene.Net/Codecs/FieldsConsumer.cs
index 1f906c7..5c79118 100644
--- a/src/Lucene.Net/Codecs/FieldsConsumer.cs
+++ b/src/Lucene.Net/Codecs/FieldsConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -86,7 +87,7 @@ namespace Lucene.Net.Codecs
             foreach (string field in fields)
             {
                 FieldInfo info = mergeState.FieldInfos.FieldInfo(field);
-                Debug.Assert(info != null, "FieldInfo for field is null: " + field);
+                Debugging.Assert(() => info != null, () => "FieldInfo for field is null: " + field);
                 Terms terms = fields.GetTerms(field);
                 if (terms != null)
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs
index 27b637c..94db36b 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xFields.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System;
 using System.Collections.Generic;
@@ -163,7 +164,7 @@ namespace Lucene.Net.Codecs.Lucene3x
         {
             get
             {
-                Debug.Assert(preTerms.Count == fields.Count);
+                Debugging.Assert(() => preTerms.Count == fields.Count);
                 return fields.Count;
             }
         }
@@ -248,7 +249,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 get
                 {
                     // preflex doesn't support this
-                    Debug.Assert(fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) < 0);
+                    Debugging.Assert(() => fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) < 0);
                     return false;
                 }
             }
@@ -303,11 +304,11 @@ namespace Lucene.Net.Codecs.Lucene3x
             {
                 int savLength = term.Length;
 
-                Debug.Assert(term.Offset == 0);
+                Debugging.Assert(() => term.Offset == 0);
 
                 // The 3 bytes starting at downTo make up 1
                 // unicode character:
-                Debug.Assert(IsHighBMPChar(term.Bytes, pos));
+                Debugging.Assert(() => IsHighBMPChar(term.Bytes, pos));
 
                 // NOTE: we cannot make this assert, because
                 // AutomatonQuery legitimately sends us malformed UTF8
@@ -360,7 +361,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 // Now test if prefix is identical and we found
                 // a non-BMP char at the same position:
                 BytesRef b2 = t2.Bytes;
-                Debug.Assert(b2.Offset == 0);
+                Debugging.Assert(() => b2.Offset == 0);
 
                 bool matches;
                 if (b2.Length >= term.Length && IsNonBMPChar(b2.Bytes, pos))
@@ -464,8 +465,8 @@ namespace Lucene.Net.Codecs.Lucene3x
                     Console.WriteLine("  try pop");
                 }
 
-                Debug.Assert(newSuffixStart <= prevTerm.Length);
-                Debug.Assert(newSuffixStart < scratchTerm.Length || newSuffixStart == 0);
+                Debugging.Assert(() => newSuffixStart <= prevTerm.Length);
+                Debugging.Assert(() => newSuffixStart < scratchTerm.Length || newSuffixStart == 0);
 
                 if (prevTerm.Length > newSuffixStart && IsNonBMPChar(prevTerm.Bytes, newSuffixStart) && IsHighBMPChar(scratchTerm.Bytes, newSuffixStart))
                 {
@@ -494,7 +495,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         }
 
                         BytesRef b2 = t2.Bytes;
-                        Debug.Assert(b2.Offset == 0);
+                        Debugging.Assert(() => b2.Offset == 0);
 
                         // Set newSuffixStart -- we can't use
                         // termEnum's since the above seek may have
@@ -595,8 +596,8 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                 // this code assumes TermInfosReader/SegmentTermEnum
                 // always use BytesRef.offset == 0
-                Debug.Assert(prevTerm.Offset == 0);
-                Debug.Assert(scratchTerm.Offset == 0);
+                Debugging.Assert(() => prevTerm.Offset == 0);
+                Debugging.Assert(() => scratchTerm.Offset == 0);
 
                 // Need to loop here because we may need to do multiple
                 // pops, and possibly a continue in the end, ie:
@@ -649,7 +650,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (IsNonBMPChar(scratchTerm.Bytes, upTo) && (upTo > newSuffixStart || (upTo >= prevTerm.Length || (!IsNonBMPChar(prevTerm.Bytes, upTo) && !IsHighBMPChar(prevTerm.Bytes, upTo)))))
                     {
                         // A non-BMP char (4 bytes UTF8) starts here:
-                        Debug.Assert(scratchTerm.Length >= upTo + 4);
+                        Debugging.Assert(() => scratchTerm.Length >= upTo + 4);
 
                         int savLength = scratchTerm.Length;
                         scratch[0] = (sbyte)scratchTerm.Bytes[upTo];
@@ -697,7 +698,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                         if (t2 != null && t2.Field == internedFieldName)
                         {
                             BytesRef b2 = t2.Bytes;
-                            Debug.Assert(b2.Offset == 0);
+                            Debugging.Assert(() => b2.Offset == 0);
                             if (b2.Length >= upTo + 3 && IsHighBMPChar(b2.Bytes, upTo))
                             {
                                 matches = true;
@@ -822,7 +823,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 TermInfosReader tis = outerInstance.TermsDict;
                 Term t0 = new Term(fieldInfo.Name, term);
 
-                Debug.Assert(termEnum != null);
+                Debugging.Assert(() => termEnum != null);
 
                 tis.SeekEnum(termEnum, t0, false);
 
@@ -853,7 +854,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     // find an E, try swapping in S, backwards:
                     scratchTerm.CopyBytes(term);
 
-                    Debug.Assert(scratchTerm.Offset == 0);
+                    Debugging.Assert(() => scratchTerm.Offset == 0);
 
                     for (int i = scratchTerm.Length - 1; i >= 0; i--)
                     {
@@ -902,7 +903,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     }
 
                     BytesRef br = t.Bytes;
-                    Debug.Assert(br.Offset == 0);
+                    Debugging.Assert(() => br.Offset == 0);
 
                     SetNewSuffixStart(term, br);
 
@@ -912,14 +913,14 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (t2 == null || t2.Field != internedFieldName)
                     {
                         // PreFlex codec interns field names; verify:
-                        Debug.Assert(t2 == null || !t2.Field.Equals(internedFieldName, StringComparison.Ordinal));
+                        Debugging.Assert(() => t2 == null || !t2.Field.Equals(internedFieldName, StringComparison.Ordinal));
                         current = null;
                         return SeekStatus.END;
                     }
                     else
                     {
                         current = t2.Bytes;
-                        Debug.Assert(!unicodeSortOrder || term.CompareTo(current) < 0, "term=" + UnicodeUtil.ToHexString(term.Utf8ToString()) + " vs current=" + UnicodeUtil.ToHexString(current.Utf8ToString()));
+                        Debugging.Assert(() => !unicodeSortOrder || term.CompareTo(current) < 0, () => "term=" + UnicodeUtil.ToHexString(term.Utf8ToString()) + " vs current=" + UnicodeUtil.ToHexString(current.Utf8ToString()));
                         return SeekStatus.NOT_FOUND;
                     }
                 }
@@ -995,7 +996,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (t == null || t.Field != internedFieldName)
                     {
                         // PreFlex codec interns field names; verify:
-                        Debug.Assert(t == null || !t.Field.Equals(internedFieldName, StringComparison.Ordinal));
+                        Debugging.Assert(() => t == null || !t.Field.Equals(internedFieldName, StringComparison.Ordinal));
                         current = null;
                     }
                     else
@@ -1020,7 +1021,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     if (t == null || t.Field != internedFieldName)
                     {
                         // PreFlex codec interns field names; verify:
-                        Debug.Assert(t == null || !t.Field.Equals(internedFieldName, StringComparison.Ordinal));
+                        Debugging.Assert(() => t == null || !t.Field.Equals(internedFieldName, StringComparison.Ordinal));
                         return null;
                     }
                     else
@@ -1189,7 +1190,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
             public override int NextPosition()
             {
-                Debug.Assert(docID != NO_MORE_DOCS);
+                Debugging.Assert(() => docID != NO_MORE_DOCS);
                 return pos.NextPosition();
             }
 
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xNormsProducer.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xNormsProducer.cs
index c33416f..5e2c5d0 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xNormsProducer.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xNormsProducer.cs
@@ -1,5 +1,6 @@
 using J2N.Threading.Atomic;
 using J2N.Runtime.CompilerServices;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -135,7 +136,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     }
                 }
                 // TODO: change to a real check? see LUCENE-3619
-                Debug.Assert(singleNormStream == null || nextNormSeek == singleNormStream.Length, singleNormStream != null ? "len: " + singleNormStream.Length + " expected: " + nextNormSeek : "null");
+                Debugging.Assert(() => singleNormStream == null || nextNormSeek == singleNormStream.Length, () => singleNormStream != null ? "len: " + singleNormStream.Length + " expected: " + nextNormSeek : "null");
                 success = true;
             }
             finally
@@ -187,7 +188,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
             else
             {
-                Debug.Assert(Convert.ToInt64(v, CultureInfo.InvariantCulture) != SegmentInfo.NO);
+                Debugging.Assert(() => Convert.ToInt64(v, CultureInfo.InvariantCulture) != SegmentInfo.NO);
                 return true;
             }
         }
@@ -257,7 +258,7 @@ namespace Lucene.Net.Codecs.Lucene3x
         public override NumericDocValues GetNumeric(FieldInfo field)
         {
             var dv = norms[field.Name];
-            Debug.Assert(dv != null);
+            Debugging.Assert(() => dv != null);
             return dv.Instance;
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs
index c5bf9ac..9b8ee15 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xSegmentInfoReader.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -192,7 +193,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
             //System.out.println("version=" + version + " name=" + name + " docCount=" + docCount + " delGen=" + delGen + " dso=" + docStoreOffset + " dss=" + docStoreSegment + " dssCFs=" + docStoreIsCompoundFile + " b=" + b + " format=" + format);
 
-            Debug.Assert(1 == b, "expected 1 but was: " + b + " format: " + format);
+            Debugging.Assert(() => 1 == b, () => "expected 1 but was: " + b + " format: " + format);
             int numNormGen = input.ReadInt32();
             IDictionary<int, long> normGen;
             if (numNormGen == SegmentInfo.NO)
@@ -210,7 +211,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             bool isCompoundFile = input.ReadByte() == SegmentInfo.YES;
 
             int delCount = input.ReadInt32();
-            Debug.Assert(delCount <= docCount);
+            Debugging.Assert(() => delCount <= docCount);
 
             bool hasProx = input.ReadByte() == 1;
 
@@ -282,7 +283,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     else
                     {
                         // We should have already hit indexformat too old exception
-                        Debug.Assert(false);
+                        Debugging.Assert(() => false);
                     }
                 }
             }
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs
index cde7643..a9eb3e5 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xStoredFieldsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using System.IO;
@@ -192,7 +193,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
                     // Verify the file is long enough to hold all of our
                     // docs
-                    Debug.Assert(((int)(indexSize / 8)) >= size + this.docStoreOffset, "indexSize=" + indexSize + " size=" + size + " docStoreOffset=" + docStoreOffset);
+                    Debugging.Assert(() => ((int)(indexSize / 8)) >= size + this.docStoreOffset, () => "indexSize=" + indexSize + " size=" + size + " docStoreOffset=" + docStoreOffset);
                 }
                 else
                 {
@@ -272,7 +273,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 FieldInfo fieldInfo = fieldInfos.FieldInfo(fieldNumber);
 
                 int bits = fieldsStream.ReadByte() & 0xFF;
-                Debug.Assert(bits <= (FIELD_IS_NUMERIC_MASK | FIELD_IS_BINARY), "bits=" + bits.ToString("x"));
+                Debugging.Assert(() => bits <= (FIELD_IS_NUMERIC_MASK | FIELD_IS_BINARY), () => "bits=" + bits.ToString("x"));
 
                 switch (visitor.NeedsField(fieldInfo))
                 {
diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
index 19c9529..7f2f5a6 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System;
 using System.Collections;
@@ -139,8 +140,8 @@ namespace Lucene.Net.Codecs.Lucene3x
                 tvf = d.OpenInput(fn, context);
                 int tvfFormat = CheckValidFormat(tvf);
 
-                Debug.Assert(format == tvdFormat);
-                Debug.Assert(format == tvfFormat);
+                Debugging.Assert(() => format == tvdFormat);
+                Debugging.Assert(() => format == tvfFormat);
 
                 numTotalDocs = (int)(tvx.Length >> 4);
 
@@ -148,7 +149,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 {
                     this.docStoreOffset = 0;
                     this.size = numTotalDocs;
-                    Debug.Assert(size == 0 || numTotalDocs == size);
+                    Debugging.Assert(() => size == 0 || numTotalDocs == size);
                 }
                 else
                 {
@@ -156,7 +157,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     this.size = size;
                     // Verify the file is long enough to hold all of our
                     // docs
-                    Debug.Assert(numTotalDocs >= size + docStoreOffset, "numTotalDocs=" + numTotalDocs + " size=" + size + " docStoreOffset=" + docStoreOffset);
+                    Debugging.Assert(() => numTotalDocs >= size + docStoreOffset, () => "numTotalDocs=" + numTotalDocs + " size=" + size + " docStoreOffset=" + docStoreOffset);
                 }
 
                 this.fieldInfos = fieldInfos;
@@ -232,7 +233,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                 outerInstance.tvd.Seek(outerInstance.tvx.ReadInt64());
 
                 int fieldCount = outerInstance.tvd.ReadVInt32();
-                Debug.Assert(fieldCount >= 0);
+                Debugging.Assert(() => fieldCount >= 0);
                 if (fieldCount != 0)
                 {
                     fieldNumbers = new int[fieldCount];
@@ -685,7 +686,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     }
                     else
                     {
-                        Debug.Assert(startOffsets != null);
+                        Debugging.Assert(() => startOffsets != null);
                         return startOffsets.Length;
                     }
                 }
@@ -736,7 +737,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
             public override int NextPosition()
             {
-                //Debug.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+                //Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
 
                 // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
                 // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
diff --git a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
index ba215e5..691e1d9 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermDocs.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using IBits = Lucene.Net.Util.IBits;
@@ -170,7 +171,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     else
                     {
                         freq = m_freqStream.ReadVInt32(); // else read freq
-                        Debug.Assert(freq != 1);
+                        Debugging.Assert(() => freq != 1);
                     }
                 }
 
diff --git a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs
index 1527672..af78aa0 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermEnum.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using FieldInfos = Lucene.Net.Index.FieldInfos;
@@ -104,8 +105,8 @@ namespace Lucene.Net.Codecs.Lucene3x
                 indexInterval = input.ReadInt32();
                 skipInterval = input.ReadInt32();
                 maxSkipLevels = input.ReadInt32();
-                Debug.Assert(indexInterval > 0, "indexInterval=" + indexInterval + " is negative; must be > 0");
-                Debug.Assert(skipInterval > 0, "skipInterval=" + skipInterval + " is negative; must be > 0");
+                Debugging.Assert(() => indexInterval > 0, () => "indexInterval=" + indexInterval + " is negative; must be > 0");
+                Debugging.Assert(() => skipInterval > 0, () => "skipInterval=" + skipInterval + " is negative; must be > 0");
             }
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
index 550a13f..87d7468 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/SegmentTermPositions.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System;
 using System.Diagnostics;
@@ -168,7 +169,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         private void SkipPositions(int n)
         {
-            Debug.Assert(m_indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+            Debugging.Assert(() => m_indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
             for (int f = n; f > 0; f--) // skip unread positions
             {
                 ReadDeltaPosition();
diff --git a/src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs b/src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs
index 8a6314a..045c149 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/TermBuffer.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -69,7 +70,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             newSuffixStart = input.ReadVInt32();
             int length = input.ReadVInt32();
             int totalLength = newSuffixStart + length;
-            Debug.Assert(totalLength <= ByteBlockPool.BYTE_BLOCK_SIZE - 2, "termLength=" + totalLength + ",resource=" + input);
+            Debugging.Assert(() => totalLength <= ByteBlockPool.BYTE_BLOCK_SIZE - 2, () => "termLength=" + totalLength + ",resource=" + input);
             if (bytes.Bytes.Length < totalLength)
             {
                 bytes.Grow(totalLength);
@@ -87,15 +88,15 @@ namespace Lucene.Net.Codecs.Lucene3x
                 }
                 else
                 {
-                    Debug.Assert(fieldInfos.FieldInfo(currentFieldNumber) != null, currentFieldNumber.ToString());
+                    Debugging.Assert(() => fieldInfos.FieldInfo(currentFieldNumber) != null, currentFieldNumber.ToString);
                     
                     field = fieldInfos.FieldInfo(currentFieldNumber).Name.Intern();
                 }
             }
             else
             {
-                Debug.Assert(field.Equals(fieldInfos.FieldInfo(fieldNumber).Name, StringComparison.Ordinal), 
-                    "currentFieldNumber=" + currentFieldNumber + 
+                Debugging.Assert(() => field.Equals(fieldInfos.FieldInfo(fieldNumber).Name, StringComparison.Ordinal),
+                    () => "currentFieldNumber=" + currentFieldNumber + 
                     " field=" + field + 
                     " vs " + fieldInfos.FieldInfo(fieldNumber) == null ? "null" : fieldInfos.FieldInfo(fieldNumber).Name);
             }
diff --git a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
index 8b7422b..cd77fbc 100644
--- a/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene3x/TermInfosReader.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
@@ -64,7 +65,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             public TermInfoAndOrd(TermInfo ti, long termOrd)
                 : base(ti)
             {
-                Debug.Assert(termOrd >= 0);
+                Debugging.Assert(() => termOrd >= 0);
                 this.termOrd = termOrd;
             }
         }
@@ -292,8 +293,8 @@ namespace Lucene.Net.Codecs.Lucene3x
                             }
                             else
                             {
-                                Debug.Assert(SameTermInfo(ti, tiOrd, enumerator));
-                                Debug.Assert(enumerator.position == tiOrd.termOrd);
+                                Debugging.Assert(() => SameTermInfo(ti, tiOrd, enumerator));
+                                Debugging.Assert(() => enumerator.position == tiOrd.termOrd);
                             }
                         }
                     }
@@ -334,8 +335,8 @@ namespace Lucene.Net.Codecs.Lucene3x
                 }
                 else
                 {
-                    Debug.Assert(SameTermInfo(ti_, tiOrd, enumerator));
-                    Debug.Assert(enumerator.position == tiOrd.termOrd);
+                    Debugging.Assert(() => SameTermInfo(ti_, tiOrd, enumerator));
+                    Debugging.Assert(() => enumerator.position == tiOrd.termOrd);
                 }
             }
             else
diff --git a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
index 5d7dfbd..e8265ce 100644
--- a/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/BitVector.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -125,7 +126,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 if (count != -1)
                 {
                     count++;
-                    Debug.Assert(count <= size);
+                    Debugging.Assert(() => count <= size);
                 }
                 return false;
             }
@@ -162,7 +163,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 if (count != -1)
                 {
                     count--;
-                    Debug.Assert(count >= 0);
+                    Debugging.Assert(() => count >= 0);
                 }
                 return true;
             }
@@ -174,7 +175,7 @@ namespace Lucene.Net.Codecs.Lucene40
         /// </summary>
         public bool Get(int bit)
         {
-            Debug.Assert(bit >= 0 && bit < size, "bit " + bit + " is out of bounds 0.." + (size - 1));
+            Debugging.Assert(() => bit >= 0 && bit < size, () => "bit " + bit + " is out of bounds 0.." + (size - 1));
             return (bits[bit >> 3] & (1 << (bit & 7))) != 0;
         }
 
@@ -201,7 +202,7 @@ namespace Lucene.Net.Codecs.Lucene40
         /// computed and cached, so that, if the vector is not changed, no
         /// recomputation is done for repeated calls.
         /// </summary>
-        public int Count()
+        public int Count() // LUCENENET TODO: API - make into a property
         {
             // if the vector has been modified
             if (count == -1)
@@ -214,7 +215,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
                 count = c;
             }
-            Debug.Assert(count <= size, "count=" + count + " size=" + size);
+            Debugging.Assert(() => count <= size, () => "count=" + count + " size=" + size);
             return count;
         }
 
@@ -258,7 +259,7 @@ namespace Lucene.Net.Codecs.Lucene40
         /// </summary>
         public void Write(Directory d, string name, IOContext context)
         {
-            Debug.Assert(!(d is CompoundFileDirectory));
+            Debugging.Assert(() => !(d is CompoundFileDirectory));
             IndexOutput output = d.CreateOutput(name, context);
             try
             {
@@ -275,7 +276,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 }
                 CodecUtil.WriteFooter(output);
                 bool verified = VerifyCount();
-                Debug.Assert(verified);
+                Debugging.Assert(() => verified);
             }
             finally
             {
@@ -351,7 +352,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     output.WriteByte(bits[i]);
                     last = i;
                     numCleared -= (8 - BitUtil.BitCount(bits[i]));
-                    Debug.Assert(numCleared >= 0 || (i == (bits.Length - 1) && numCleared == -(8 - (size & 7))));
+                    Debugging.Assert(() => numCleared >= 0 || (i == (bits.Length - 1) && numCleared == -(8 - (size & 7))));
                 }
             }
         }
@@ -460,8 +461,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     CodecUtil.CheckEOF(input);
 #pragma warning restore 612, 618
                 }
-                bool verified = VerifyCount();
-                Debug.Assert(verified);
+                Debugging.Assert(VerifyCount);
             }
             finally
             {
@@ -472,11 +472,11 @@ namespace Lucene.Net.Codecs.Lucene40
         // asserts only
         private bool VerifyCount()
         {
-            Debug.Assert(count != -1);
+            Debugging.Assert(() => count != -1);
             int countSav = count;
             count = -1;
             bool checkCount = countSav == Count();
-            Debug.Assert(checkCount, "saved count was " + countSav + " but recomputed count is " + count);
+            Debugging.Assert(() => checkCount, () => "saved count was " + countSav + " but recomputed count is " + count);
             return true;
         }
 
@@ -503,7 +503,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 last += input.ReadVInt32();
                 bits[last] = input.ReadByte();
                 n -= BitUtil.BitCount(bits[last]);
-                Debug.Assert(n >= 0);
+                Debugging.Assert(() => n >= 0);
             }
         }
 
@@ -526,7 +526,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 last += input.ReadVInt32();
                 bits[last] = input.ReadByte();
                 numCleared -= 8 - BitUtil.BitCount(bits[last]);
-                Debug.Assert(numCleared >= 0 || (last == (bits.Length - 1) && numCleared == -(8 - (size & 7))));
+                Debugging.Assert(() => numCleared >= 0 || (last == (bits.Length - 1) && numCleared == -(8 - (size & 7))));
             }
         }
     }
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40LiveDocsFormat.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40LiveDocsFormat.cs
index fd0efe5..98dc1a6 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40LiveDocsFormat.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40LiveDocsFormat.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -91,9 +92,8 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             string filename = IndexFileNames.FileNameFromGeneration(info.Info.Name, DELETES_EXTENSION, info.DelGen);
             BitVector liveDocs = new BitVector(dir, filename, context);
-            int liveDocsCount = liveDocs.Count();
-            Debug.Assert(liveDocsCount == info.Info.DocCount - info.DelCount, "liveDocs.count()=" + liveDocsCount + " info.docCount=" + info.Info.DocCount + " info.getDelCount()=" + info.DelCount);
-            Debug.Assert(liveDocs.Length == info.Info.DocCount);
+            Debugging.Assert(() => liveDocs.Count() == info.Info.DocCount - info.DelCount, () => "liveDocs.count()=" + liveDocs.Count() + " info.docCount=" + info.Info.DocCount + " info.getDelCount()=" + info.DelCount);
+            Debugging.Assert(() => liveDocs.Length == info.Info.DocCount);
             return liveDocs;
         }
 
@@ -102,9 +102,8 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             string filename = IndexFileNames.FileNameFromGeneration(info.Info.Name, DELETES_EXTENSION, info.NextDelGen);
             BitVector liveDocs = (BitVector)bits;
-            int liveDocsCount = liveDocs.Count();
-            Debug.Assert(liveDocsCount == info.Info.DocCount - info.DelCount - newDelCount);
-            Debug.Assert(liveDocs.Length == info.Info.DocCount);
+            Debugging.Assert(() => liveDocs.Count() == info.Info.DocCount - info.DelCount - newDelCount);
+            Debugging.Assert(() => liveDocs.Length == info.Info.DocCount);
             liveDocs.Write(dir, filename, context);
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsFormat.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsFormat.cs
index 84f4b70..b19545d 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsFormat.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsFormat.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -234,7 +235,7 @@ namespace Lucene.Net.Codecs.Lucene40
             : base()
         {
             this.m_minBlockSize = minBlockSize;
-            Debug.Assert(minBlockSize > 1);
+            Debugging.Assert(() => minBlockSize > 1);
             this.m_maxBlockSize = maxBlockSize;
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
index df2549d..c2a5f96 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40PostingsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System;
@@ -192,13 +193,13 @@ namespace Lucene.Net.Codecs.Lucene40
               System.out.println("  freqFP=" + termState2.freqOffset);
             }
             */
-            Debug.Assert(termState2.freqOffset < freqIn.Length);
+            Debugging.Assert(() => termState2.freqOffset < freqIn.Length);
 
             if (termState2.DocFreq >= skipMinimum)
             {
                 termState2.skipOffset = @in.ReadVInt64();
                 // if (DEBUG) System.out.println("  skipOffset=" + termState2.skipOffset + " vs freqIn.length=" + freqIn.length());
-                Debug.Assert(termState2.freqOffset + termState2.skipOffset < freqIn.Length);
+                Debugging.Assert(() => termState2.freqOffset + termState2.skipOffset < freqIn.Length);
             }
             else
             {
@@ -355,7 +356,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 // cases
                 freqIn.Seek(termState.freqOffset);
                 m_limit = termState.DocFreq;
-                Debug.Assert(m_limit > 0);
+                Debugging.Assert(() => m_limit > 0);
                 m_ord = 0;
                 m_doc = -1;
                 m_accum = 0;
@@ -545,7 +546,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 : base(outerInstance, startFreqIn, null)
             {
                 this.outerInstance = outerInstance;
-                Debug.Assert(m_liveDocs == null);
+                Debugging.Assert(() => m_liveDocs == null);
             }
 
             public override int NextDoc()
@@ -638,7 +639,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 : base(outerInstance, startFreqIn, liveDocs)
             {
                 this.outerInstance = outerInstance;
-                Debug.Assert(liveDocs != null);
+                Debugging.Assert(() => liveDocs != null);
             }
 
             public override int NextDoc()
@@ -782,8 +783,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
             public SegmentDocsAndPositionsEnum Reset(FieldInfo fieldInfo, StandardTermState termState, IBits liveDocs)
             {
-                Debug.Assert(fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
-                Debug.Assert(!fieldInfo.HasPayloads);
+                Debugging.Assert(() => fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS);
+                Debugging.Assert(() => !fieldInfo.HasPayloads);
 
                 this.liveDocs = liveDocs;
 
@@ -794,7 +795,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 lazyProxPointer = termState.proxOffset;
 
                 limit = termState.DocFreq;
-                Debug.Assert(limit > 0);
+                Debugging.Assert(() => limit > 0);
 
                 ord = 0;
                 doc = -1;
@@ -929,7 +930,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
                 posPendingCount--;
 
-                Debug.Assert(posPendingCount >= 0, "nextPosition() was called too many times (more than freq() times) posPendingCount=" + posPendingCount);
+                Debugging.Assert(() => posPendingCount >= 0, () => "nextPosition() was called too many times (more than freq() times) posPendingCount=" + posPendingCount);
 
                 return position;
             }
@@ -1002,8 +1003,8 @@ namespace Lucene.Net.Codecs.Lucene40
             {
                 storeOffsets = fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
                 storePayloads = fieldInfo.HasPayloads;
-                Debug.Assert(fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0);
-                Debug.Assert(storePayloads || storeOffsets);
+                Debugging.Assert(() => fieldInfo.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0);
+                Debugging.Assert(() => storePayloads || storeOffsets);
                 if (payload == null)
                 {
                     payload = new BytesRef();
@@ -1159,9 +1160,9 @@ namespace Lucene.Net.Codecs.Lucene40
                         {
                             // new payload length
                             payloadLength = proxIn.ReadVInt32();
-                            Debug.Assert(payloadLength >= 0);
+                            Debugging.Assert(() => payloadLength >= 0);
                         }
-                        Debug.Assert(payloadLength != -1);
+                        Debugging.Assert(() => payloadLength != -1);
                     }
 
                     if (storeOffsets)
@@ -1199,9 +1200,9 @@ namespace Lucene.Net.Codecs.Lucene40
                     {
                         // new payload length
                         payloadLength = proxIn.ReadVInt32();
-                        Debug.Assert(payloadLength >= 0);
+                        Debugging.Assert(() => payloadLength >= 0);
                     }
-                    Debug.Assert(payloadLength != -1);
+                    Debugging.Assert(() => payloadLength != -1);
 
                     payloadPending = true;
                     code_ = (int)((uint)code_ >> 1);
@@ -1221,7 +1222,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
                 posPendingCount--;
 
-                Debug.Assert(posPendingCount >= 0, "nextPosition() was called too many times (more than freq() times) posPendingCount=" + posPendingCount);
+                Debugging.Assert(() => posPendingCount >= 0, () => "nextPosition() was called too many times (more than freq() times) posPendingCount=" + posPendingCount);
 
                 //System.out.println("StandardR.D&PE nextPos   return pos=" + position);
                 return position;
@@ -1243,8 +1244,8 @@ namespace Lucene.Net.Codecs.Lucene40
                     {
                         return null;
                     }
-                    Debug.Assert(lazyProxPointer == -1);
-                    Debug.Assert(posPendingCount < freq);
+                    Debugging.Assert(() => lazyProxPointer == -1);
+                    Debugging.Assert(() => posPendingCount < freq);
 
                     if (payloadPending)
                     {
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsReader.cs
index 33ea318..7057d68 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 using System.IO;
@@ -91,8 +92,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
                 CodecUtil.CheckHeader(indexStream, Lucene40StoredFieldsWriter.CODEC_NAME_IDX, Lucene40StoredFieldsWriter.VERSION_START, Lucene40StoredFieldsWriter.VERSION_CURRENT);
                 CodecUtil.CheckHeader(fieldsStream, Lucene40StoredFieldsWriter.CODEC_NAME_DAT, Lucene40StoredFieldsWriter.VERSION_START, Lucene40StoredFieldsWriter.VERSION_CURRENT);
-                Debug.Assert(Lucene40StoredFieldsWriter.HEADER_LENGTH_DAT == fieldsStream.GetFilePointer());
-                Debug.Assert(Lucene40StoredFieldsWriter.HEADER_LENGTH_IDX == indexStream.GetFilePointer());
+                Debugging.Assert(() => Lucene40StoredFieldsWriter.HEADER_LENGTH_DAT == fieldsStream.GetFilePointer());
+                Debugging.Assert(() => Lucene40StoredFieldsWriter.HEADER_LENGTH_IDX == indexStream.GetFilePointer());
                 long indexSize = indexStream.Length - Lucene40StoredFieldsWriter.HEADER_LENGTH_IDX;
                 this.size = (int)(indexSize >> 3);
                 // Verify two sources of "maxDoc" agree:
@@ -173,7 +174,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 FieldInfo fieldInfo = fieldInfos.FieldInfo(fieldNumber);
 
                 int bits = fieldsStream.ReadByte() & 0xFF;
-                Debug.Assert(bits <= (Lucene40StoredFieldsWriter.FIELD_IS_NUMERIC_MASK | Lucene40StoredFieldsWriter.FIELD_IS_BINARY), "bits=" + bits.ToString("x"));
+                Debugging.Assert(() => bits <= (Lucene40StoredFieldsWriter.FIELD_IS_NUMERIC_MASK | Lucene40StoredFieldsWriter.FIELD_IS_BINARY), () => "bits=" + bits.ToString("x"));
 
                 switch (visitor.NeedsField(fieldInfo))
                 {
@@ -280,7 +281,7 @@ namespace Lucene.Net.Codecs.Lucene40
             {
                 long offset;
                 int docID = startDocID + count + 1;
-                Debug.Assert(docID <= numTotalDocs);
+                Debugging.Assert(() => docID <= numTotalDocs);
                 if (docID < numTotalDocs)
                 {
                     offset = indexStream.ReadInt64();
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
index ca8ba56..4e39ff1 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40StoredFieldsWriter.cs
@@ -1,4 +1,5 @@
 using J2N;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using System;
 using System.Diagnostics;
@@ -90,7 +91,7 @@ namespace Lucene.Net.Codecs.Lucene40
         /// Sole constructor. </summary>
         public Lucene40StoredFieldsWriter(Directory directory, string segment, IOContext context)
         {
-            Debug.Assert(directory != null);
+            Debugging.Assert(() => directory != null);
             this.directory = directory;
             this.segment = segment;
 
@@ -102,8 +103,8 @@ namespace Lucene.Net.Codecs.Lucene40
 
                 CodecUtil.WriteHeader(fieldsStream, CODEC_NAME_DAT, VERSION_CURRENT);
                 CodecUtil.WriteHeader(indexStream, CODEC_NAME_IDX, VERSION_CURRENT);
-                Debug.Assert(HEADER_LENGTH_DAT == fieldsStream.GetFilePointer());
-                Debug.Assert(HEADER_LENGTH_IDX == indexStream.GetFilePointer());
+                Debugging.Assert(() => HEADER_LENGTH_DAT == fieldsStream.GetFilePointer());
+                Debugging.Assert(() => HEADER_LENGTH_IDX == indexStream.GetFilePointer());
                 success = true;
             }
             finally
@@ -262,7 +263,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 position += lengths[i];
             }
             fieldsStream.CopyBytes(stream, position - start);
-            Debug.Assert(fieldsStream.GetFilePointer() == position);
+            Debugging.Assert(() => fieldsStream.GetFilePointer() == position);
         }
 
         public override void Finish(FieldInfos fis, int numDocs)
@@ -324,7 +325,7 @@ namespace Lucene.Net.Codecs.Lucene40
             int docCount = 0;
             int maxDoc = reader.MaxDoc;
             IBits liveDocs = reader.LiveDocs;
-            Debug.Assert(liveDocs != null);
+            Debugging.Assert(() => liveDocs != null);
             if (matchingFieldsReader != null)
             {
                 // We can bulk-copy because the fieldInfos are "congruent"
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
index fcef1e6..ceca2e2 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System;
@@ -119,16 +120,16 @@ namespace Lucene.Net.Codecs.Lucene40
                 fn = IndexFileNames.SegmentFileName(segment, "", VECTORS_FIELDS_EXTENSION);
                 tvf = d.OpenInput(fn, context);
                 int tvfVersion = CodecUtil.CheckHeader(tvf, CODEC_NAME_FIELDS, VERSION_START, VERSION_CURRENT);
-                Debug.Assert(HEADER_LENGTH_INDEX == tvx.GetFilePointer());
-                Debug.Assert(HEADER_LENGTH_DOCS == tvd.GetFilePointer());
-                Debug.Assert(HEADER_LENGTH_FIELDS == tvf.GetFilePointer());
-                Debug.Assert(tvxVersion == tvdVersion);
-                Debug.Assert(tvxVersion == tvfVersion);
+                Debugging.Assert(() => HEADER_LENGTH_INDEX == tvx.GetFilePointer());
+                Debugging.Assert(() => HEADER_LENGTH_DOCS == tvd.GetFilePointer());
+                Debugging.Assert(() => HEADER_LENGTH_FIELDS == tvf.GetFilePointer());
+                Debugging.Assert(() => tvxVersion == tvdVersion);
+                Debugging.Assert(() => tvxVersion == tvfVersion);
 
                 numTotalDocs = (int)(tvx.Length - HEADER_LENGTH_INDEX >> 4);
 
                 this.size = numTotalDocs;
-                Debug.Assert(size == 0 || numTotalDocs == size);
+                Debugging.Assert(() => size == 0 || numTotalDocs == size);
 
                 this.fieldInfos = fieldInfos;
                 success = true;
@@ -199,7 +200,7 @@ namespace Lucene.Net.Codecs.Lucene40
             while (count < numDocs)
             {
                 int docID = startDocID + count + 1;
-                Debug.Assert(docID <= numTotalDocs);
+                Debugging.Assert(() => docID <= numTotalDocs);
                 if (docID < numTotalDocs)
                 {
                     tvdPosition = tvx.ReadInt64();
@@ -209,7 +210,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 {
                     tvdPosition = tvd.Length;
                     tvfPosition = tvf.Length;
-                    Debug.Assert(count == numDocs - 1);
+                    Debugging.Assert(() => count == numDocs - 1);
                 }
                 tvdLengths[count] = (int)(tvdPosition - lastTvdPosition);
                 tvfLengths[count] = (int)(tvfPosition - lastTvfPosition);
@@ -247,7 +248,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 outerInstance.tvd.Seek(outerInstance.tvx.ReadInt64());
 
                 int fieldCount = outerInstance.tvd.ReadVInt32();
-                Debug.Assert(fieldCount >= 0);
+                Debugging.Assert(() => fieldCount >= 0);
                 if (fieldCount != 0)
                 {
                     fieldNumbers = new int[fieldCount];
@@ -517,7 +518,7 @@ namespace Lucene.Net.Codecs.Lucene40
                         }
                         payloadOffsets[posUpto] = totalPayloadLength;
                         totalPayloadLength += lastPayloadLength;
-                        Debug.Assert(totalPayloadLength >= 0);
+                        Debugging.Assert(() => totalPayloadLength >= 0);
                     }
                     payloadData = new byte[totalPayloadLength];
                     tvf.ReadBytes(payloadData, 0, payloadData.Length);
@@ -667,7 +668,7 @@ namespace Lucene.Net.Codecs.Lucene40
                     }
                     else
                     {
-                        Debug.Assert(startOffsets != null);
+                        Debugging.Assert(() => startOffsets != null);
                         return startOffsets.Length;
                     }
                 }
@@ -729,7 +730,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             public override int NextPosition()
             {
-                //Debug.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
+                //Debugging.Assert((positions != null && nextPos < positions.Length) || startOffsets != null && nextPos < startOffsets.Length);
 
                 // LUCENENET: The above assertion was for control flow when testing. In Java, it would throw an AssertionError, which is
                 // caught by the BaseTermVectorsFormatTestCase.assertEquals(RandomTokenStream tk, FieldType ft, Terms terms) method in the
diff --git a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
index 0098850..0a6e736 100644
--- a/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene40/Lucene40TermVectorsWriter.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -77,9 +78,9 @@ namespace Lucene.Net.Codecs.Lucene40
                 CodecUtil.WriteHeader(tvd, Lucene40TermVectorsReader.CODEC_NAME_DOCS, Lucene40TermVectorsReader.VERSION_CURRENT);
                 tvf = directory.CreateOutput(IndexFileNames.SegmentFileName(segment, "", Lucene40TermVectorsReader.VECTORS_FIELDS_EXTENSION), context);
                 CodecUtil.WriteHeader(tvf, Lucene40TermVectorsReader.CODEC_NAME_FIELDS, Lucene40TermVectorsReader.VERSION_CURRENT);
-                Debug.Assert(Lucene40TermVectorsReader.HEADER_LENGTH_INDEX == tvx.GetFilePointer());
-                Debug.Assert(Lucene40TermVectorsReader.HEADER_LENGTH_DOCS == tvd.GetFilePointer());
-                Debug.Assert(Lucene40TermVectorsReader.HEADER_LENGTH_FIELDS == tvf.GetFilePointer());
+                Debugging.Assert(() => Lucene40TermVectorsReader.HEADER_LENGTH_INDEX == tvx.GetFilePointer());
+                Debugging.Assert(() => Lucene40TermVectorsReader.HEADER_LENGTH_DOCS == tvd.GetFilePointer());
+                Debugging.Assert(() => Lucene40TermVectorsReader.HEADER_LENGTH_FIELDS == tvf.GetFilePointer());
                 success = true;
             }
             finally
@@ -109,7 +110,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
         public override void StartField(FieldInfo info, int numTerms, bool positions, bool offsets, bool payloads)
         {
-            Debug.Assert(lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
+            Debugging.Assert(() => lastFieldName == null || info.Name.CompareToOrdinal(lastFieldName) > 0, () => "fieldName=" + info.Name + " lastFieldName=" + lastFieldName);
             lastFieldName = info.Name;
             this.positions = positions;
             this.offsets = offsets;
@@ -138,7 +139,7 @@ namespace Lucene.Net.Codecs.Lucene40
         [MethodImpl(MethodImplOptions.NoInlining)]
         public override void FinishDocument()
         {
-            Debug.Assert(fieldCount == numVectorFields);
+            Debugging.Assert(() => fieldCount == numVectorFields);
             for (int i = 1; i < fieldCount; i++)
             {
                 tvd.WriteVInt64(fps[i] - fps[i - 1]);
@@ -267,8 +268,8 @@ namespace Lucene.Net.Codecs.Lucene40
             if (bufferedIndex > 0)
             {
                 // dump buffer
-                Debug.Assert(positions && (offsets || payloads));
-                Debug.Assert(bufferedIndex == bufferedFreq);
+                Debugging.Assert(() => positions && (offsets || payloads));
+                Debugging.Assert(() => bufferedIndex == bufferedFreq);
                 if (payloads)
                 {
                     tvf.WriteBytes(payloadData.Bytes, payloadData.Offset, payloadData.Length);
@@ -356,8 +357,8 @@ namespace Lucene.Net.Codecs.Lucene40
             }
             tvd.CopyBytes(reader.TvdStream, tvdPosition - tvdStart);
             tvf.CopyBytes(reader.TvfStream, tvfPosition - tvfStart);
-            Debug.Assert(tvd.GetFilePointer() == tvdPosition);
-            Debug.Assert(tvf.GetFilePointer() == tvfPosition);
+            Debugging.Assert(() => tvd.GetFilePointer() == tvdPosition);
+            Debugging.Assert(() => tvf.GetFilePointer() == tvfPosition);
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
diff --git a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
index 212178d..cb39d5e 100644
--- a/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/ForUtil.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Util.Packed;
@@ -87,7 +88,7 @@ namespace Lucene.Net.Codecs.Lucene41
         private static int EncodedSize(PackedInt32s.Format format, int packedIntsVersion, int bitsPerValue)
         {
             long byteCount = format.ByteCount(packedIntsVersion, Lucene41PostingsFormat.BLOCK_SIZE, bitsPerValue);
-            Debug.Assert(byteCount >= 0 && byteCount <= int.MaxValue, byteCount.ToString());
+            Debugging.Assert(() => byteCount >= 0 && byteCount <= int.MaxValue, byteCount.ToString);
             return (int)byteCount;
         }
 
@@ -110,8 +111,8 @@ namespace Lucene.Net.Codecs.Lucene41
             for (int bpv = 1; bpv <= 32; ++bpv)
             {
                 PackedInt32s.FormatAndBits formatAndBits = PackedInt32s.FastestFormatAndBits(Lucene41PostingsFormat.BLOCK_SIZE, bpv, acceptableOverheadRatio);
-                Debug.Assert(formatAndBits.Format.IsSupported(formatAndBits.BitsPerValue));
-                Debug.Assert(formatAndBits.BitsPerValue <= 32);
+                Debugging.Assert(() => formatAndBits.Format.IsSupported(formatAndBits.BitsPerValue));
+                Debugging.Assert(() => formatAndBits.BitsPerValue <= 32);
                 encodedSizes[bpv] = EncodedSize(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
                 encoders[bpv] = PackedInt32s.GetEncoder(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
                 decoders[bpv] = PackedInt32s.GetDecoder(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
@@ -140,7 +141,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 var bitsPerValue = (code & 31) + 1;
 
                 PackedInt32s.Format format = PackedInt32s.Format.ById(formatId);
-                Debug.Assert(format.IsSupported(bitsPerValue));
+                Debugging.Assert(() => format.IsSupported(bitsPerValue));
                 encodedSizes[bpv] = EncodedSize(format, packedIntsVersion, bitsPerValue);
                 encoders[bpv] = PackedInt32s.GetEncoder(format, packedIntsVersion, bitsPerValue);
                 decoders[bpv] = PackedInt32s.GetDecoder(format, packedIntsVersion, bitsPerValue);
@@ -165,12 +166,12 @@ namespace Lucene.Net.Codecs.Lucene41
             }
 
             int numBits = BitsRequired(data);
-            Debug.Assert(numBits > 0 && numBits <= 32, numBits.ToString());
+            Debugging.Assert(() => numBits > 0 && numBits <= 32, numBits.ToString);
             PackedInt32s.IEncoder encoder = encoders[numBits];
             int iters = iterations[numBits];
-            Debug.Assert(iters * encoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
+            Debugging.Assert(() => iters * encoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
             int encodedSize = encodedSizes[numBits];
-            Debug.Assert(iters * encoder.ByteBlockCount >= encodedSize);
+            Debugging.Assert(() => iters * encoder.ByteBlockCount >= encodedSize);
 
             @out.WriteByte((byte)numBits);
 
@@ -188,7 +189,7 @@ namespace Lucene.Net.Codecs.Lucene41
         internal void ReadBlock(IndexInput @in, byte[] encoded, int[] decoded)
         {
             int numBits = @in.ReadByte();
-            Debug.Assert(numBits <= 32, numBits.ToString());
+            Debugging.Assert(() => numBits <= 32, numBits.ToString);
 
             if (numBits == ALL_VALUES_EQUAL)
             {
@@ -202,7 +203,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
             PackedInt32s.IDecoder decoder = decoders[numBits];
             int iters = iterations[numBits];
-            Debug.Assert(iters * decoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
+            Debugging.Assert(() => iters * decoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
 
             decoder.Decode(encoded, 0, decoded, 0, iters);
         }
@@ -220,7 +221,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 @in.ReadVInt32();
                 return;
             }
-            Debug.Assert(numBits > 0 && numBits <= 32, numBits.ToString());
+            Debugging.Assert(() => numBits > 0 && numBits <= 32, numBits.ToString);
             int encodedSize = encodedSizes[numBits];
             @in.Seek(@in.GetFilePointer() + encodedSize);
         }
@@ -247,7 +248,7 @@ namespace Lucene.Net.Codecs.Lucene41
             long or = 0;
             for (int i = 0; i < Lucene41PostingsFormat.BLOCK_SIZE; ++i)
             {
-                Debug.Assert(data[i] >= 0);
+                Debugging.Assert(() => data[i] >= 0);
                 or |= (uint)data[i];
             }
             return PackedInt32s.BitsRequired(or);
diff --git a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsFormat.cs b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsFormat.cs
index f1c9f13..02115c9 100644
--- a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsFormat.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsFormat.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 
 namespace Lucene.Net.Codecs.Lucene41
 {
@@ -392,9 +392,9 @@ namespace Lucene.Net.Codecs.Lucene41
             : base()
         {
             this.minTermBlockSize = minTermBlockSize;
-            Debug.Assert(minTermBlockSize > 1);
+            Debugging.Assert(() => minTermBlockSize > 1);
             this.maxTermBlockSize = maxTermBlockSize;
-            Debug.Assert(minTermBlockSize <= maxTermBlockSize);
+            Debugging.Assert(() => minTermBlockSize <= maxTermBlockSize);
         }
 
         public override string ToString()
diff --git a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
index fbf1e8d..0ef9de6 100644
--- a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
@@ -401,7 +402,7 @@ namespace Lucene.Net.Codecs.Lucene41
             private void RefillDocs()
             {
                 int left = docFreq - docUpto;
-                Debug.Assert(left > 0);
+                Debugging.Assert(() => left > 0);
 
                 if (left >= Lucene41PostingsFormat.BLOCK_SIZE)
                 {
@@ -510,7 +511,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
                     if (!skipped)
                     {
-                        Debug.Assert(skipOffset != -1);
+                        Debugging.Assert(() => skipOffset != -1);
                         // this is the first time this enum has skipped
                         // since reset() was called; load the skip data:
                         skipper.Init(docTermStartFP + skipOffset, docTermStartFP, 0, 0, docFreq);
@@ -527,7 +528,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         // if (DEBUG) {
                         //   System.out.println("skipper moved to docUpto=" + newDocUpto + " vs current=" + docUpto + "; docID=" + skipper.getDoc() + " fp=" + skipper.getDocPointer());
                         // }
-                        Debug.Assert(newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, "got " + newDocUpto);
+                        Debugging.Assert(() => newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, () => "got " + newDocUpto);
                         docUpto = newDocUpto;
 
                         // Force to read next block
@@ -730,7 +731,7 @@ namespace Lucene.Net.Codecs.Lucene41
             private void RefillDocs()
             {
                 int left = docFreq - docUpto;
-                Debug.Assert(left > 0);
+                Debugging.Assert(() => left > 0);
 
                 if (left >= Lucene41PostingsFormat.BLOCK_SIZE)
                 {
@@ -874,7 +875,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
                     if (!skipped)
                     {
-                        Debug.Assert(skipOffset != -1);
+                        Debugging.Assert(() => skipOffset != -1);
                         // this is the first time this enum has skipped
                         // since reset() was called; load the skip data:
                         // if (DEBUG) {
@@ -893,7 +894,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         //   System.out.println("    skipper moved to docUpto=" + newDocUpto + " vs current=" + docUpto + "; docID=" + skipper.getDoc() + " fp=" + skipper.getDocPointer() + " pos.fp=" + skipper.getPosPointer() + " pos.bufferUpto=" + skipper.getPosBufferUpto());
                         // }
 
-                        Debug.Assert(newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, "got " + newDocUpto);
+                        Debugging.Assert(() => newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, () => "got " + newDocUpto);
                         docUpto = newDocUpto;
 
                         // Force to read next block
@@ -982,7 +983,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         // if (DEBUG) {
                         //   System.out.println("        skip whole block @ fp=" + posIn.getFilePointer());
                         // }
-                        Debug.Assert(posIn.GetFilePointer() != lastPosBlockFP);
+                        Debugging.Assert(() => posIn.GetFilePointer() != lastPosBlockFP);
                         outerInstance.forUtil.SkipBlock(posIn);
                         toSkip -= Lucene41PostingsFormat.BLOCK_SIZE;
                     }
@@ -1235,7 +1236,7 @@ namespace Lucene.Net.Codecs.Lucene41
             private void RefillDocs()
             {
                 int left = docFreq - docUpto;
-                Debug.Assert(left > 0);
+                Debugging.Assert(() => left > 0);
 
                 if (left >= Lucene41PostingsFormat.BLOCK_SIZE)
                 {
@@ -1449,7 +1450,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
                     if (!skipped)
                     {
-                        Debug.Assert(skipOffset != -1);
+                        Debugging.Assert(() => skipOffset != -1);
                         // this is the first time this enum has skipped
                         // since reset() was called; load the skip data:
                         // if (DEBUG) {
@@ -1467,7 +1468,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         // if (DEBUG) {
                         //   System.out.println("    skipper moved to docUpto=" + newDocUpto + " vs current=" + docUpto + "; docID=" + skipper.getDoc() + " fp=" + skipper.getDocPointer() + " pos.fp=" + skipper.getPosPointer() + " pos.bufferUpto=" + skipper.getPosBufferUpto() + " pay.fp=" + skipper.getPayPointer() + " lastStartOffset=" + lastStartOffset);
                         // }
-                        Debug.Assert(newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, "got " + newDocUpto);
+                        Debugging.Assert(() => newDocUpto % Lucene41PostingsFormat.BLOCK_SIZE == 0, () => "got " + newDocUpto);
                         docUpto = newDocUpto;
 
                         // Force to read next block
@@ -1567,7 +1568,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         // if (DEBUG) {
                         //   System.out.println("        skip whole block @ fp=" + posIn.getFilePointer());
                         // }
-                        Debug.Assert(posIn.GetFilePointer() != lastPosBlockFP);
+                        Debugging.Assert(() => posIn.GetFilePointer() != lastPosBlockFP);
                         outerInstance.forUtil.SkipBlock(posIn);
 
                         if (indexHasPayloads)
diff --git a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsWriter.cs b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsWriter.cs
index e2c44e6..a60d951 100644
--- a/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/Lucene41PostingsWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -376,8 +377,8 @@ namespace Lucene.Net.Codecs.Lucene41
 
             if (fieldHasOffsets)
             {
-                Debug.Assert(startOffset >= lastStartOffset);
-                Debug.Assert(endOffset >= startOffset);
+                Debugging.Assert(() => startOffset >= lastStartOffset);
+                Debugging.Assert(() => endOffset >= startOffset);
                 offsetStartDeltaBuffer[posBufferUpto] = startOffset - lastStartOffset;
                 offsetLengthBuffer[posBufferUpto] = endOffset - startOffset;
                 lastStartOffset = startOffset;
@@ -438,11 +439,11 @@ namespace Lucene.Net.Codecs.Lucene41
         public override void FinishTerm(BlockTermState state)
         {
             Int32BlockTermState state2 = (Int32BlockTermState)state;
-            Debug.Assert(state2.DocFreq > 0);
+            Debugging.Assert(() => state2.DocFreq > 0);
 
             // TODO: wasteful we are counting this (counting # docs
             // for this term) in two places?
-            Debug.Assert(state2.DocFreq == docCount, state2.DocFreq + " vs " + docCount);
+            Debugging.Assert(() => state2.DocFreq == docCount, () => state2.DocFreq + " vs " + docCount);
 
             // if (DEBUG) {
             //   System.out.println("FPW.finishTerm docFreq=" + state2.docFreq);
@@ -497,7 +498,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
                 // totalTermFreq is just total number of positions(or payloads, or offsets)
                 // associated with current term.
-                Debug.Assert(state2.TotalTermFreq != -1);
+                Debugging.Assert(() => state2.TotalTermFreq != -1);
                 if (state2.TotalTermFreq > Lucene41PostingsFormat.BLOCK_SIZE)
                 {
                     // record file offset for last pos in last block
@@ -575,7 +576,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
                     if (fieldHasPayloads)
                     {
-                        Debug.Assert(payloadBytesReadUpto == payloadByteUpto);
+                        Debugging.Assert(() => payloadBytesReadUpto == payloadByteUpto);
                         payloadByteUpto = 0;
                     }
                 }
diff --git a/src/Lucene.Net/Codecs/Lucene41/Lucene41SkipReader.cs b/src/Lucene.Net/Codecs/Lucene41/Lucene41SkipReader.cs
index 5b411dd..6b459ce 100644
--- a/src/Lucene.Net/Codecs/Lucene41/Lucene41SkipReader.cs
+++ b/src/Lucene.Net/Codecs/Lucene41/Lucene41SkipReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System.Diagnostics;
 
@@ -128,7 +129,7 @@ namespace Lucene.Net.Codecs.Lucene41
             }
             else
             {
-                Debug.Assert(posBasePointer == 0);
+                Debugging.Assert(() => posBasePointer == 0);
             }
         }
 
diff --git a/src/Lucene.Net/Codecs/Lucene42/Lucene42NormsConsumer.cs b/src/Lucene.Net/Codecs/Lucene42/Lucene42NormsConsumer.cs
index 541bddf..c32c676 100644
--- a/src/Lucene.Net/Codecs/Lucene42/Lucene42NormsConsumer.cs
+++ b/src/Lucene.Net/Codecs/Lucene42/Lucene42NormsConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -92,7 +93,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 long count = 0;
                 foreach (long? nv in values)
                 {
-                    Debug.Assert(nv != null);
+                    Debugging.Assert(() => nv != null);
                     long v = nv.Value;
 
                     if (gcd != 1)
@@ -126,7 +127,7 @@ namespace Lucene.Net.Codecs.Lucene42
 
                     ++count;
                 }
-                Debug.Assert(count == maxDoc);
+                Debugging.Assert(() => count == maxDoc);
             }
 
             if (uniqueValues != null)
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
index c0ac98b..49deb1b 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -494,13 +495,13 @@ namespace Lucene.Net.Codecs.Lucene45
                 }
                 else
                 {
-                    Debug.Assert(current == 1);
+                    Debugging.Assert(() => current == 1);
                     ordsIter.MoveNext();
                     yield return ordsIter.Current;
                 }
             }
 
-            Debug.Assert(!ordsIter.MoveNext());
+            Debugging.Assert(() => !ordsIter.MoveNext());
         }
 
         protected override void Dispose(bool disposing)
diff --git a/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosWriter.cs b/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosWriter.cs
index 1600241..52be418 100644
--- a/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosWriter.cs
+++ b/src/Lucene.Net/Codecs/Lucene46/Lucene46FieldInfosWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -72,7 +73,7 @@ namespace Lucene.Net.Codecs.Lucene46
                     if (fi.IsIndexed)
                     {
                         bits |= Lucene46FieldInfosFormat.IS_INDEXED;
-                        Debug.Assert(indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
+                        Debugging.Assert(() => indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) >= 0 || !fi.HasPayloads);
                         if (indexOptions == IndexOptions.DOCS_ONLY)
                         {
                             bits |= Lucene46FieldInfosFormat.OMIT_TERM_FREQ_AND_POSITIONS;
@@ -93,7 +94,7 @@ namespace Lucene.Net.Codecs.Lucene46
                     // pack the DV types in one byte
                     var dv = DocValuesByte(fi.DocValuesType);
                     var nrm = DocValuesByte(fi.NormType);
-                    Debug.Assert((dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
+                    Debugging.Assert(() => (dv & (~0xF)) == 0 && (nrm & (~0x0F)) == 0);
                     var val = (byte)(0xff & ((nrm << 4) | (byte)dv));
                     output.WriteByte(val);
                     output.WriteInt64(fi.DocValuesGen);
diff --git a/src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs b/src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs
index 3930a40..ecdb5bd 100644
--- a/src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs
+++ b/src/Lucene.Net/Codecs/MappingMultiDocsEnum.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Diagnostics;
@@ -105,7 +106,7 @@ namespace Lucene.Net.Codecs
                         current = subs[upto].DocsEnum;
                         currentBase = mergeState.DocBase[reader];
                         currentMap = mergeState.DocMaps[reader];
-                        Debug.Assert(currentMap.MaxDoc == subs[upto].Slice.Length, "readerIndex=" + reader + " subs.len=" + subs.Length + " len1=" + currentMap.MaxDoc + " vs " + subs[upto].Slice.Length);
+                        Debugging.Assert(() => currentMap.MaxDoc == subs[upto].Slice.Length, () => "readerIndex=" + reader + " subs.len=" + subs.Length + " len1=" + currentMap.MaxDoc + " vs " + subs[upto].Slice.Length);
                     }
                 }
 
diff --git a/src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs b/src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs
index 1fecf80..c652034 100644
--- a/src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs
+++ b/src/Lucene.Net/Codecs/MultiLevelSkipListReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -252,7 +253,7 @@ namespace Lucene.Net.Codecs
         {
             this.skipPointer[0] = skipPointer;
             this.docCount = df;
-            Debug.Assert(skipPointer >= 0 && skipPointer <= skipStream[0].Length, "invalid skip pointer: " + skipPointer + ", length=" + skipStream[0].Length);
+            Debugging.Assert(() => skipPointer >= 0 && skipPointer <= skipStream[0].Length, () => "invalid skip pointer: " + skipPointer + ", length=" + skipStream[0].Length);
             Array.Clear(m_skipDoc, 0, m_skipDoc.Length);
             Array.Clear(numSkipped, 0, numSkipped.Length);
             Array.Clear(childPointer, 0, childPointer.Length);
diff --git a/src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs b/src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs
index ac82fe5..beb24e4 100644
--- a/src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs
+++ b/src/Lucene.Net/Codecs/MultiLevelSkipListWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 using System.IO;
 
@@ -147,7 +148,7 @@ namespace Lucene.Net.Codecs
         /// <exception cref="IOException"> If an I/O error occurs. </exception>
         public virtual void BufferSkip(int df)
         {
-            Debug.Assert(df % skipInterval == 0);
+            Debugging.Assert(() => df % skipInterval == 0);
             int numLevels = 1;
             df /= skipInterval;
 
diff --git a/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs b/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
index a0f4012..d9904c6 100644
--- a/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net/Codecs/PerField/PerFieldDocValuesFormat.cs
@@ -1,4 +1,5 @@
 using J2N.Runtime.CompilerServices;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -154,7 +155,7 @@ namespace Lucene.Net.Codecs.PerField
                 string formatName_ = format.Name;
 
                 string previousValue = field.PutAttribute(PER_FIELD_FORMAT_KEY, formatName_);
-                Debug.Assert(field.DocValuesGen != -1 || previousValue == null, "formatName=" + formatName_ + " prevValue=" + previousValue);
+                Debugging.Assert(() => field.DocValuesGen != -1 || previousValue == null, () => "formatName=" + formatName_ + " prevValue=" + previousValue);
 
                 int? suffix = null;
 
@@ -198,12 +199,12 @@ namespace Lucene.Net.Codecs.PerField
                 else
                 {
                     // we've already seen this format, so just grab its suffix
-                    Debug.Assert(suffixes.ContainsKey(formatName_));
+                    Debugging.Assert(() => suffixes.ContainsKey(formatName_));
                     suffix = consumer.Suffix;
                 }
 
                 previousValue = field.PutAttribute(PER_FIELD_SUFFIX_KEY, Convert.ToString(suffix, CultureInfo.InvariantCulture));
-                Debug.Assert(field.DocValuesGen != -1 || previousValue == null, "suffix=" + Convert.ToString(suffix, CultureInfo.InvariantCulture) + " prevValue=" + previousValue);
+                Debugging.Assert(() => field.DocValuesGen != -1 || previousValue == null, () => "suffix=" + Convert.ToString(suffix, CultureInfo.InvariantCulture) + " prevValue=" + previousValue);
 
                 // TODO: we should only provide the "slice" of FIS
                 // that this DVF actually sees ...
@@ -264,7 +265,7 @@ namespace Lucene.Net.Codecs.PerField
                             {
                                 // null formatName means the field is in fieldInfos, but has no docvalues!
                                 string suffix = fi.GetAttribute(PER_FIELD_SUFFIX_KEY);
-                                Debug.Assert(suffix != null);
+                                Debugging.Assert(() => suffix != null);
                                 DocValuesFormat format = DocValuesFormat.ForName(formatName);
                                 string segmentSuffix = GetFullSegmentSuffix(readState.SegmentSuffix, GetSuffix(formatName, suffix));
                                 // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
@@ -305,7 +306,7 @@ namespace Lucene.Net.Codecs.PerField
                 {
                     DocValuesProducer producer;
                     oldToNew.TryGetValue(ent.Value, out producer);
-                    Debug.Assert(producer != null);
+                    Debugging.Assert(() => producer != null);
                     fields[ent.Key] = producer;
                 }
             }
diff --git a/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs b/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
index 8c3d72d..e5dbc96 100644
--- a/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
+++ b/src/Lucene.Net/Codecs/PerField/PerFieldPostingsFormat.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -115,7 +116,7 @@ namespace Lucene.Net.Codecs.PerField
                 string formatName = format.Name;
 
                 string previousValue = field.PutAttribute(PER_FIELD_FORMAT_KEY, formatName);
-                Debug.Assert(previousValue == null);
+                Debugging.Assert(() => previousValue == null);
 
                 int? suffix;
 
@@ -146,12 +147,12 @@ namespace Lucene.Net.Codecs.PerField
                 else
                 {
                     // we've already seen this format, so just grab its suffix
-                    Debug.Assert(suffixes.ContainsKey(formatName));
+                    Debugging.Assert(() => suffixes.ContainsKey(formatName));
                     suffix = consumer.Suffix;
                 }
 
                 previousValue = field.PutAttribute(PER_FIELD_SUFFIX_KEY, Convert.ToString(suffix, CultureInfo.InvariantCulture));
-                Debug.Assert(previousValue == null);
+                Debugging.Assert(() => previousValue == null);
 
                 // TODO: we should only provide the "slice" of FIS
                 // that this PF actually sees ... then stuff like
@@ -218,7 +219,7 @@ namespace Lucene.Net.Codecs.PerField
                             {
                                 // null formatName means the field is in fieldInfos, but has no postings!
                                 string suffix = fi.GetAttribute(PER_FIELD_SUFFIX_KEY);
-                                Debug.Assert(suffix != null);
+                                Debugging.Assert(() => suffix != null);
                                 PostingsFormat format = PostingsFormat.ForName(formatName);
                                 string segmentSuffix = GetSuffix(formatName, suffix);
                                 // LUCENENET: Eliminated extra lookup by using TryGetValue instead of ContainsKey
diff --git a/src/Lucene.Net/Codecs/PostingsConsumer.cs b/src/Lucene.Net/Codecs/PostingsConsumer.cs
index 93588a9..aff9f0e 100644
--- a/src/Lucene.Net/Codecs/PostingsConsumer.cs
+++ b/src/Lucene.Net/Codecs/PostingsConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -150,7 +151,7 @@ namespace Lucene.Net.Codecs
             }
             else
             {
-                Debug.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
+                Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
                 var postingsEnum = (DocsAndPositionsEnum)postings;
                 while (true)
                 {
diff --git a/src/Lucene.Net/Codecs/TermVectorsWriter.cs b/src/Lucene.Net/Codecs/TermVectorsWriter.cs
index 5a636dd..028e99d 100644
--- a/src/Lucene.Net/Codecs/TermVectorsWriter.cs
+++ b/src/Lucene.Net/Codecs/TermVectorsWriter.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -285,7 +286,7 @@ namespace Lucene.Net.Codecs
                 fieldCount++;
                 FieldInfo fieldInfo = mergeState.FieldInfos.FieldInfo(fieldName);
 
-                Debug.Assert(lastFieldName == null || fieldName.CompareToOrdinal(lastFieldName) > 0, "lastFieldName=" + lastFieldName + " fieldName=" + fieldName);
+                Debugging.Assert(() => lastFieldName == null || fieldName.CompareToOrdinal(lastFieldName) > 0, () => "lastFieldName=" + lastFieldName + " fieldName=" + fieldName);
                 lastFieldName = fieldName;
 
                 Terms terms = vectors.GetTerms(fieldName);
@@ -298,7 +299,7 @@ namespace Lucene.Net.Codecs
                 bool hasPositions = terms.HasPositions;
                 bool hasOffsets = terms.HasOffsets;
                 bool hasPayloads = terms.HasPayloads;
-                Debug.Assert(!hasPayloads || hasPositions);
+                Debugging.Assert(() => !hasPayloads || hasPositions);
 
                 int numTerms = (int)terms.Count;
                 if (numTerms == -1)
@@ -327,11 +328,11 @@ namespace Lucene.Net.Codecs
                     if (hasPositions || hasOffsets)
                     {
                         docsAndPositionsEnum = termsEnum.DocsAndPositions(null, docsAndPositionsEnum);
-                        Debug.Assert(docsAndPositionsEnum != null);
+                        Debugging.Assert(() => docsAndPositionsEnum != null);
 
                         int docID = docsAndPositionsEnum.NextDoc();
-                        Debug.Assert(docID != DocIdSetIterator.NO_MORE_DOCS);
-                        Debug.Assert(docsAndPositionsEnum.Freq == freq);
+                        Debugging.Assert(() => docID != DocIdSetIterator.NO_MORE_DOCS);
+                        Debugging.Assert(() => docsAndPositionsEnum.Freq == freq);
 
                         for (int posUpto = 0; posUpto < freq; posUpto++)
                         {
@@ -341,16 +342,16 @@ namespace Lucene.Net.Codecs
 
                             BytesRef payload = docsAndPositionsEnum.GetPayload();
 
-                            Debug.Assert(!hasPositions || pos >= 0);
+                            Debugging.Assert(() => !hasPositions || pos >= 0);
                             AddPosition(pos, startOffset, endOffset, payload);
                         }
                     }
                     FinishTerm();
                 }
-                Debug.Assert(termCount == numTerms);
+                Debugging.Assert(() => termCount == numTerms);
                 FinishField();
             }
-            Debug.Assert(fieldCount == numFields);
+            Debugging.Assert(() => fieldCount == numFields);
             FinishDocument();
         }
 
diff --git a/src/Lucene.Net/Codecs/TermsConsumer.cs b/src/Lucene.Net/Codecs/TermsConsumer.cs
index b731f01..08f4c4a 100644
--- a/src/Lucene.Net/Codecs/TermsConsumer.cs
+++ b/src/Lucene.Net/Codecs/TermsConsumer.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -100,7 +101,7 @@ namespace Lucene.Net.Codecs
         public virtual void Merge(MergeState mergeState, IndexOptions indexOptions, TermsEnum termsEnum)
         {
             BytesRef term;
-            Debug.Assert(termsEnum != null);
+            Debugging.Assert(() => termsEnum != null);
             long sumTotalTermFreq = 0;
             long sumDocFreq = 0;
             long sumDFsinceLastAbortCheck = 0;
@@ -156,7 +157,7 @@ namespace Lucene.Net.Codecs
                     // We can pass null for liveDocs, because the
                     // mapping enum will skip the non-live docs:
                     docsAndFreqsEnumIn = (MultiDocsEnum)termsEnum.Docs(null, docsAndFreqsEnumIn);
-                    Debug.Assert(docsAndFreqsEnumIn != null);
+                    Debugging.Assert(() => docsAndFreqsEnumIn != null);
                     docsAndFreqsEnum.Reset(docsAndFreqsEnumIn);
                     PostingsConsumer postingsConsumer = StartTerm(term);
                     TermStats stats = postingsConsumer.Merge(mergeState, indexOptions, docsAndFreqsEnum, visitedDocs);
@@ -187,7 +188,7 @@ namespace Lucene.Net.Codecs
                     // We can pass null for liveDocs, because the
                     // mapping enum will skip the non-live docs:
                     postingsEnumIn = (MultiDocsAndPositionsEnum)termsEnum.DocsAndPositions(null, postingsEnumIn, DocsAndPositionsFlags.PAYLOADS);
-                    Debug.Assert(postingsEnumIn != null);
+                    Debugging.Assert(() => postingsEnumIn != null);
                     postingsEnum.Reset(postingsEnumIn);
 
                     PostingsConsumer postingsConsumer = StartTerm(term);
@@ -208,7 +209,7 @@ namespace Lucene.Net.Codecs
             }
             else
             {
-                Debug.Assert(indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
+                Debugging.Assert(() => indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
                 if (postingsEnum == null)
                 {
                     postingsEnum = new MappingMultiDocsAndPositionsEnum();
@@ -220,7 +221,7 @@ namespace Lucene.Net.Codecs
                     // We can pass null for liveDocs, because the
                     // mapping enum will skip the non-live docs:
                     postingsEnumIn = (MultiDocsAndPositionsEnum)termsEnum.DocsAndPositions(null, postingsEnumIn);
-                    Debug.Assert(postingsEnumIn != null);
+                    Debugging.Assert(() => postingsEnumIn != null);
                     postingsEnum.Reset(postingsEnumIn);
 
                     PostingsConsumer postingsConsumer = StartTerm(term);
diff --git a/src/Lucene.Net/Index/AtomicReader.cs b/src/Lucene.Net/Index/AtomicReader.cs
index 3e4f1eb..8639d42 100644
--- a/src/Lucene.Net/Index/AtomicReader.cs
+++ b/src/Lucene.Net/Index/AtomicReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 using System;
 
@@ -210,8 +211,8 @@ namespace Lucene.Net.Index
         /// <seealso cref="TermsEnum.Docs(IBits, DocsEnum)"/>
         public DocsEnum GetTermDocsEnum(Term term) // LUCENENET specific: Renamed from TermDocsEnum()
         {
-            Debug.Assert(term.Field != null);
-            Debug.Assert(term.Bytes != null);
+            Debugging.Assert(() => term.Field != null);
+            Debugging.Assert(() => term.Bytes != null);
             Fields fields = Fields;
             if (fields != null)
             {
@@ -235,8 +236,8 @@ namespace Lucene.Net.Index
         /// <seealso cref="TermsEnum.DocsAndPositions(IBits, DocsAndPositionsEnum)"/>
         public DocsAndPositionsEnum GetTermPositionsEnum(Term term) // LUCENENET specific: Renamed from TermPositionsEnum()
         {
-            Debug.Assert(term.Field != null);
-            Debug.Assert(term.Bytes != null);
+            Debugging.Assert(() => term.Field != null);
+            Debugging.Assert(() => term.Bytes != null);
             Fields fields = Fields;
             if (fields != null)
             {
diff --git a/src/Lucene.Net/Index/AtomicReaderContext.cs b/src/Lucene.Net/Index/AtomicReaderContext.cs
index 0cffc46..ab0a60c 100644
--- a/src/Lucene.Net/Index/AtomicReaderContext.cs
+++ b/src/Lucene.Net/Index/AtomicReaderContext.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -62,7 +63,7 @@ namespace Lucene.Net.Index
                 {
                     throw new NotSupportedException("this is not a top-level context.");
                 }
-                Debug.Assert(leaves != null);
+                Debugging.Assert(() => leaves != null);
                 return leaves;
             }
         }
diff --git a/src/Lucene.Net/Index/AutomatonTermsEnum.cs b/src/Lucene.Net/Index/AutomatonTermsEnum.cs
index b505e86..553e0be 100644
--- a/src/Lucene.Net/Index/AutomatonTermsEnum.cs
+++ b/src/Lucene.Net/Index/AutomatonTermsEnum.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -90,7 +91,7 @@ namespace Lucene.Net.Index
         {
             this.finite = compiled.Finite;
             this.runAutomaton = compiled.RunAutomaton;
-            Debug.Assert(this.runAutomaton != null);
+            Debugging.Assert(() => this.runAutomaton != null);
             this.commonSuffixRef = compiled.CommonSuffixRef;
             this.allTransitions = compiled.SortedTransitions;
 
@@ -128,7 +129,7 @@ namespace Lucene.Net.Index
             //System.out.println("ATE.nextSeekTerm term=" + term);
             if (term == null)
             {
-                Debug.Assert(seekBytesRef.Length == 0);
+                Debugging.Assert(() => seekBytesRef.Length == 0);
                 // return the empty term, as its valid
                 if (runAutomaton.IsAccept(runAutomaton.InitialState))
                 {
@@ -158,14 +159,14 @@ namespace Lucene.Net.Index
         /// </summary>
         private void SetLinear(int position)
         {
-            Debug.Assert(linear == false);
+            Debugging.Assert(() => linear == false);
 
             int state = runAutomaton.InitialState;
             int maxInterval = 0xff;
             for (int i = 0; i < position; i++)
             {
                 state = runAutomaton.Step(state, seekBytesRef.Bytes[i] & 0xff);
-                Debug.Assert(state >= 0, "state=" + state);
+                Debugging.Assert(() => state >= 0, () => "state=" + state);
             }
             for (int i = 0; i < allTransitions[state].Length; i++)
             {
diff --git a/src/Lucene.Net/Index/BitsSlice.cs b/src/Lucene.Net/Index/BitsSlice.cs
index 06bbfea..965b234 100644
--- a/src/Lucene.Net/Index/BitsSlice.cs
+++ b/src/Lucene.Net/Index/BitsSlice.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -39,7 +40,7 @@ namespace Lucene.Net.Index
             this.parent = parent;
             this.start = slice.Start;
             this.length = slice.Length;
-            Debug.Assert(length >= 0, "length=" + length);
+            Debugging.Assert(() => length >= 0, () => "length=" + length);
         }
 
         public bool Get(int doc)
@@ -48,7 +49,7 @@ namespace Lucene.Net.Index
             {
                 throw new Exception("doc " + doc + " is out of bounds 0 .. " + (length - 1));
             }
-            Debug.Assert(doc < length, "doc=" + doc + " length=" + length);
+            Debugging.Assert(() => doc < length, () => "doc=" + doc + " length=" + length);
             return parent.Get(doc + start);
         }
 
diff --git a/src/Lucene.Net/Index/BufferedUpdatesStream.cs b/src/Lucene.Net/Index/BufferedUpdatesStream.cs
index 4c634ec..f3eedcc 100644
--- a/src/Lucene.Net/Index/BufferedUpdatesStream.cs
+++ b/src/Lucene.Net/Index/BufferedUpdatesStream.cs
@@ -1,5 +1,6 @@
 using J2N.Text;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using System;
 using System.Collections.Generic;
@@ -87,10 +88,10 @@ namespace Lucene.Net.Index
                  * since deletes are applied to the wrong segments.
                  */
                 packet.DelGen = nextGen++;
-                Debug.Assert(packet.Any());
-                Debug.Assert(CheckDeleteStats());
-                Debug.Assert(packet.DelGen < nextGen);
-                Debug.Assert(updates.Count == 0 || updates[updates.Count - 1].DelGen < packet.DelGen, "Delete packets must be in order");
+                Debugging.Assert(packet.Any);
+                Debugging.Assert(CheckDeleteStats);
+                Debugging.Assert(() => packet.DelGen < nextGen);
+                Debugging.Assert(() => updates.Count == 0 || updates[updates.Count - 1].DelGen < packet.DelGen, () => "Delete packets must be in order");
                 updates.Add(packet);
                 numTerms.AddAndGet(packet.numTermDeletes);
                 bytesUsed.AddAndGet(packet.bytesUsed);
@@ -98,7 +99,7 @@ namespace Lucene.Net.Index
                 {
                     infoStream.Message("BD", "push deletes " + packet + " delGen=" + packet.DelGen + " packetCount=" + updates.Count + " totBytesUsed=" + bytesUsed);
                 }
-                Debug.Assert(CheckDeleteStats());
+                Debugging.Assert(CheckDeleteStats);
                 return packet.DelGen;
             }
         }
@@ -174,7 +175,7 @@ namespace Lucene.Net.Index
                     return new ApplyDeletesResult(false, nextGen++, null);
                 }
 
-                Debug.Assert(CheckDeleteStats());
+                Debugging.Assert(CheckDeleteStats);
 
                 if (!Any())
                 {
@@ -235,11 +236,11 @@ namespace Lucene.Net.Index
                     }
                     else if (packet != null && segGen == packet.DelGen)
                     {
-                        Debug.Assert(packet.isSegmentPrivate, "Packet and Segments deletegen can only match on a segment private del packet gen=" + segGen);
+                        Debugging.Assert(() => packet.isSegmentPrivate, () => "Packet and Segments deletegen can only match on a segment private del packet gen=" + segGen);
                         //System.out.println("  eq");
 
                         // Lock order: IW -> BD -> RP
-                        Debug.Assert(readerPool.InfoIsLive(info));
+                        Debugging.Assert(() => readerPool.InfoIsLive(info));
                         ReadersAndUpdates rld = readerPool.Get(info, true);
                         SegmentReader reader = rld.GetReader(IOContext.READ);
                         int delCount = 0;
@@ -266,7 +267,7 @@ namespace Lucene.Net.Index
                                 rld.WriteFieldUpdates(info.Info.Dir, dvUpdates);
                             }
                             int fullDelCount = rld.Info.DelCount + rld.PendingDeleteCount;
-                            Debug.Assert(fullDelCount <= rld.Info.Info.DocCount);
+                            Debugging.Assert(() => fullDelCount <= rld.Info.Info.DocCount);
                             segAllDeletes = fullDelCount == rld.Info.Info.DocCount;
                         }
                         finally
@@ -311,7 +312,7 @@ namespace Lucene.Net.Index
                         if (coalescedUpdates != null)
                         {
                             // Lock order: IW -> BD -> RP
-                            Debug.Assert(readerPool.InfoIsLive(info));
+                            Debugging.Assert(() => readerPool.InfoIsLive(info));
                             ReadersAndUpdates rld = readerPool.Get(info, true);
                             SegmentReader reader = rld.GetReader(IOContext.READ);
                             int delCount = 0;
@@ -328,7 +329,7 @@ namespace Lucene.Net.Index
                                     rld.WriteFieldUpdates(info.Info.Dir, dvUpdates);
                                 }
                                 int fullDelCount = rld.Info.DelCount + rld.PendingDeleteCount;
-                                Debug.Assert(fullDelCount <= rld.Info.Info.DocCount);
+                                Debugging.Assert(() => fullDelCount <= rld.Info.Info.DocCount);
                                 segAllDeletes = fullDelCount == rld.Info.Info.DocCount;
                             }
                             finally
@@ -358,7 +359,7 @@ namespace Lucene.Net.Index
                     }
                 }
 
-                Debug.Assert(CheckDeleteStats());
+                Debugging.Assert(CheckDeleteStats);
                 if (infoStream.IsEnabled("BD"))
                 {
                     infoStream.Message("BD", "applyDeletes took " + (Environment.TickCount - t0) + " msec");
@@ -388,7 +389,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                Debug.Assert(CheckDeleteStats());
+                Debugging.Assert(CheckDeleteStats);
                 long minGen = long.MaxValue;
                 foreach (SegmentCommitInfo info in segmentInfos.Segments)
                 {
@@ -405,15 +406,15 @@ namespace Lucene.Net.Index
                     if (updates[delIDX].DelGen >= minGen)
                     {
                         Prune(delIDX);
-                        Debug.Assert(CheckDeleteStats());
+                        Debugging.Assert(CheckDeleteStats);
                         return;
                     }
                 }
 
                 // All deletes pruned
                 Prune(limit);
-                Debug.Assert(!Any());
-                Debug.Assert(CheckDeleteStats());
+                Debugging.Assert(() => !Any());
+                Debugging.Assert(CheckDeleteStats);
             }
         }
 
@@ -431,9 +432,9 @@ namespace Lucene.Net.Index
                     {
                         FrozenBufferedUpdates packet = updates[delIDX];
                         numTerms.AddAndGet(-packet.numTermDeletes);
-                        Debug.Assert(numTerms >= 0);
+                        Debugging.Assert(() => numTerms >= 0);
                         bytesUsed.AddAndGet(-packet.bytesUsed);
-                        Debug.Assert(bytesUsed >= 0);
+                        Debugging.Assert(() => bytesUsed >= 0);
                     }
                     updates.SubList(0, count).Clear();
                 }
@@ -458,7 +459,7 @@ namespace Lucene.Net.Index
                 string currentField = null;
                 DocsEnum docs = null;
 
-                Debug.Assert(CheckDeleteTerm(null));
+                Debugging.Assert(() => CheckDeleteTerm(null));
 
                 bool any = false;
 
@@ -470,7 +471,7 @@ namespace Lucene.Net.Index
                     // forwards
                     if (!string.Equals(term.Field, currentField, StringComparison.Ordinal))
                     {
-                        Debug.Assert(currentField == null || currentField.CompareToOrdinal(term.Field) < 0);
+                        Debugging.Assert(() => currentField == null || currentField.CompareToOrdinal(term.Field) < 0);
                         currentField = term.Field;
                         Terms terms = fields.GetTerms(currentField);
                         if (terms != null)
@@ -487,7 +488,7 @@ namespace Lucene.Net.Index
                     {
                         continue;
                     }
-                    Debug.Assert(CheckDeleteTerm(term));
+                    Debugging.Assert(() => CheckDeleteTerm(term));
 
                     // System.out.println("  term=" + term);
 
@@ -681,7 +682,7 @@ namespace Lucene.Net.Index
         {
             if (term != null)
             {
-                Debug.Assert(lastDeleteTerm == null || term.CompareTo(lastDeleteTerm) > 0, "lastTerm=" + lastDeleteTerm + " vs term=" + term);
+                Debugging.Assert(() => lastDeleteTerm == null || term.CompareTo(lastDeleteTerm) > 0, () => "lastTerm=" + lastDeleteTerm + " vs term=" + term);
             }
             // TODO: we re-use term now in our merged iterable, but we shouldn't clone, instead copy for this assert
             lastDeleteTerm = term == null ? null : new Term(term.Field, BytesRef.DeepCopyOf(term.Bytes));
@@ -698,8 +699,8 @@ namespace Lucene.Net.Index
                 numTerms2 += packet.numTermDeletes;
                 bytesUsed2 += packet.bytesUsed;
             }
-            Debug.Assert(numTerms2 == numTerms, "numTerms2=" + numTerms2 + " vs " + numTerms);
-            Debug.Assert(bytesUsed2 == bytesUsed, "bytesUsed2=" + bytesUsed2 + " vs " + bytesUsed);
+            Debugging.Assert(() => numTerms2 == numTerms, () => "numTerms2=" + numTerms2 + " vs " + numTerms);
+            Debugging.Assert(() => bytesUsed2 == bytesUsed, () => "bytesUsed2=" + bytesUsed2 + " vs " + bytesUsed);
             return true;
         }
     }
diff --git a/src/Lucene.Net/Index/ByteSliceReader.cs b/src/Lucene.Net/Index/ByteSliceReader.cs
index 47061ec..5380c5d 100644
--- a/src/Lucene.Net/Index/ByteSliceReader.cs
+++ b/src/Lucene.Net/Index/ByteSliceReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Diagnostics;
 
@@ -47,9 +48,9 @@ namespace Lucene.Net.Index
 
         public void Init(ByteBlockPool pool, int startIndex, int endIndex)
         {
-            Debug.Assert(endIndex - startIndex >= 0);
-            Debug.Assert(startIndex >= 0);
-            Debug.Assert(endIndex >= 0);
+            Debugging.Assert(() => endIndex - startIndex >= 0);
+            Debugging.Assert(() => startIndex >= 0);
+            Debugging.Assert(() => endIndex >= 0);
 
             this.pool = pool;
             this.EndIndex = endIndex;
@@ -75,14 +76,14 @@ namespace Lucene.Net.Index
 
         public bool Eof()
         {
-            Debug.Assert(upto + BufferOffset <= EndIndex);
+            Debugging.Assert(() => upto + BufferOffset <= EndIndex);
             return upto + BufferOffset == EndIndex;
         }
 
         public override byte ReadByte()
         {
-            Debug.Assert(!Eof());
-            Debug.Assert(upto <= limit);
+            Debugging.Assert(() => !Eof());
+            Debugging.Assert(() => upto <= limit);
             if (upto == limit)
             {
                 NextSlice();
@@ -97,7 +98,7 @@ namespace Lucene.Net.Index
             {
                 if (limit + BufferOffset == EndIndex)
                 {
-                    Debug.Assert(EndIndex - BufferOffset >= upto);
+                    Debugging.Assert(() => EndIndex - BufferOffset >= upto);
                     @out.WriteBytes(buffer, upto, limit - upto);
                     size += limit - upto;
                     break;
@@ -130,7 +131,7 @@ namespace Lucene.Net.Index
             if (nextIndex + newSize >= EndIndex)
             {
                 // We are advancing to the final slice
-                Debug.Assert(EndIndex - nextIndex > 0);
+                Debugging.Assert(() => EndIndex - nextIndex > 0);
                 limit = EndIndex - BufferOffset;
             }
             else
diff --git a/src/Lucene.Net/Index/ByteSliceWriter.cs b/src/Lucene.Net/Index/ByteSliceWriter.cs
index b4dca87..e51789e 100644
--- a/src/Lucene.Net/Index/ByteSliceWriter.cs
+++ b/src/Lucene.Net/Index/ByteSliceWriter.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System.Diagnostics;
 
 namespace Lucene.Net.Index
@@ -46,26 +47,26 @@ namespace Lucene.Net.Index
         public void Init(int address)
         {
             slice = pool.Buffers[address >> ByteBlockPool.BYTE_BLOCK_SHIFT];
-            Debug.Assert(slice != null);
+            Debugging.Assert(() => slice != null);
             upto = address & ByteBlockPool.BYTE_BLOCK_MASK;
             offset0 = address;
-            Debug.Assert(upto < slice.Length);
+            Debugging.Assert(() => upto < slice.Length);
         }
 
         /// <summary>
         /// Write byte into byte slice stream </summary>
         public override void WriteByte(byte b)
         {
-            Debug.Assert(slice != null);
+            Debugging.Assert(() => slice != null);
             if (slice[upto] != 0)
             {
                 upto = pool.AllocSlice(slice, upto);
                 slice = pool.Buffer;
                 offset0 = pool.ByteOffset;
-                Debug.Assert(slice != null);
+                Debugging.Assert(() => slice != null);
             }
             slice[upto++] = (byte)b;
-            Debug.Assert(upto != slice.Length);
+            Debugging.Assert(() => upto != slice.Length);
         }
 
         public override void WriteBytes(byte[] b, int offset, int len)
@@ -82,7 +83,7 @@ namespace Lucene.Net.Index
                 }
 
                 slice[upto++] = (byte)b[offset++];
-                Debug.Assert(upto != slice.Length);
+                Debugging.Assert(() => upto != slice.Length);
             }
         }
 
diff --git a/src/Lucene.Net/Index/CheckIndex.cs b/src/Lucene.Net/Index/CheckIndex.cs
index 11581c5..2d58581 100644
--- a/src/Lucene.Net/Index/CheckIndex.cs
+++ b/src/Lucene.Net/Index/CheckIndex.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using Lucene.Net.Support;
 using Lucene.Net.Support.IO;
@@ -948,7 +949,7 @@ namespace Lucene.Net.Index
                     if (info.HasNorms)
                     {
 #pragma warning disable 612, 618
-                        Debug.Assert(reader.HasNorms(info.Name)); // deprecated path
+                        Debugging.Assert(() => reader.HasNorms(info.Name)); // deprecated path
 #pragma warning restore 612, 618
                         CheckNorms(info, reader, infoStream);
                         ++status.TotFields;
@@ -956,7 +957,7 @@ namespace Lucene.Net.Index
                     else
                     {
 #pragma warning disable 612, 618
-                        Debug.Assert(!reader.HasNorms(info.Name)); // deprecated path
+                        Debugging.Assert(() => !reader.HasNorms(info.Name)); // deprecated path
 #pragma warning restore 612, 618
                         if (reader.GetNormValues(info.Name) != null)
                         {
@@ -1101,7 +1102,7 @@ namespace Lucene.Net.Index
                         break;
                     }
 
-                    Debug.Assert(term.IsValid());
+                    Debugging.Assert(term.IsValid);
 
                     // make sure terms arrive in order according to
                     // the comp
@@ -1236,7 +1237,7 @@ namespace Lucene.Net.Index
                                 BytesRef payload = postings.GetPayload();
                                 if (payload != null)
                                 {
-                                    Debug.Assert(payload.IsValid());
+                                    Debugging.Assert(payload.IsValid);
                                 }
                                 if (payload != null && payload.Length < 1)
                                 {
@@ -1454,7 +1455,7 @@ namespace Lucene.Net.Index
                     if (fieldTerms is BlockTreeTermsReader.FieldReader)
                     {
                         BlockTreeTermsReader.Stats stats = ((BlockTreeTermsReader.FieldReader)fieldTerms).ComputeStats();
-                        Debug.Assert(stats != null);
+                        Debugging.Assert(() => stats != null);
                         if (status.BlockTreeStats == null)
                         {
                             status.BlockTreeStats = new Dictionary<string, BlockTreeTermsReader.Stats>();
@@ -1809,7 +1810,7 @@ namespace Lucene.Net.Index
             for (int i = 0; i < reader.MaxDoc; i++)
             {
                 dv.Get(i, scratch);
-                Debug.Assert(scratch.IsValid());
+                Debugging.Assert(scratch.IsValid);
                 if (docsWithField.Get(i) == false && scratch.Length > 0)
                 {
                     throw new Exception("dv for field: " + fieldName + " is missing but has value=" + scratch + " for doc: " + i);
@@ -1860,7 +1861,7 @@ namespace Lucene.Net.Index
             for (int i = 0; i <= maxOrd; i++)
             {
                 dv.LookupOrd(i, scratch);
-                Debug.Assert(scratch.IsValid());
+                Debugging.Assert(scratch.IsValid);
                 if (lastValue != null)
                 {
                     if (scratch.CompareTo(lastValue) <= 0)
@@ -1952,7 +1953,7 @@ namespace Lucene.Net.Index
             for (long i = 0; i <= maxOrd; i++)
             {
                 dv.LookupOrd(i, scratch);
-                Debug.Assert(scratch.IsValid());
+                Debugging.Assert(scratch.IsValid);
                 if (lastValue != null)
                 {
                     if (scratch.CompareTo(lastValue) <= 0)
@@ -2155,25 +2156,25 @@ namespace Lucene.Net.Index
                                     if (hasProx)
                                     {
                                         postings = termsEnum.DocsAndPositions(null, postings);
-                                        Debug.Assert(postings != null);
+                                        Debugging.Assert(() => postings != null);
                                         docs = null;
                                     }
                                     else
                                     {
                                         docs = termsEnum.Docs(null, docs);
-                                        Debug.Assert(docs != null);
+                                        Debugging.Assert(() => docs != null);
                                         postings = null;
                                     }
 
                                     DocsEnum docs2;
                                     if (hasProx)
                                     {
-                                        Debug.Assert(postings != null);
+                                        Debugging.Assert(() => postings != null);
                                         docs2 = postings;
                                     }
                                     else
                                     {
-                                        Debug.Assert(docs != null);
+                                        Debugging.Assert(() => docs != null);
                                         docs2 = docs;
                                     }
 
@@ -2271,12 +2272,12 @@ namespace Lucene.Net.Index
 
                                                 if (payload != null)
                                                 {
-                                                    Debug.Assert(vectorsHasPayload);
+                                                    Debugging.Assert(() => vectorsHasPayload);
                                                 }
 
                                                 if (postingsHasPayload && vectorsHasPayload)
                                                 {
-                                                    Debug.Assert(postingsPostings != null);
+                                                    Debugging.Assert(() => postingsPostings != null);
 
                                                     if (payload == null)
                                                     {
@@ -2365,7 +2366,7 @@ namespace Lucene.Net.Index
 
         private static bool AssertsOn()
         {
-            Debug.Assert(TestAsserts());
+            Debugging.Assert(TestAsserts);
             return assertsOn;
         }
 
diff --git a/src/Lucene.Net/Index/CompositeReader.cs b/src/Lucene.Net/Index/CompositeReader.cs
index 313e981..430efba 100644
--- a/src/Lucene.Net/Index/CompositeReader.cs
+++ b/src/Lucene.Net/Index/CompositeReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -82,7 +83,7 @@ namespace Lucene.Net.Index
             }
             buffer.Append('(');
             var subReaders = GetSequentialSubReaders();
-            Debug.Assert(subReaders != null);
+            Debugging.Assert(() => subReaders != null);
             if (subReaders.Count > 0)
             {
                 buffer.Append(subReaders[0]);
@@ -114,7 +115,7 @@ namespace Lucene.Net.Index
                 // lazy init without thread safety for perf reasons: Building the readerContext twice does not hurt!
                 if (readerContext == null)
                 {
-                    Debug.Assert(GetSequentialSubReaders() != null);
+                    Debugging.Assert(() => GetSequentialSubReaders() != null);
                     readerContext = CompositeReaderContext.Create(this);
                 }
                 return readerContext;
diff --git a/src/Lucene.Net/Index/CompositeReaderContext.cs b/src/Lucene.Net/Index/CompositeReaderContext.cs
index 1e19ead..e4188dc 100644
--- a/src/Lucene.Net/Index/CompositeReaderContext.cs
+++ b/src/Lucene.Net/Index/CompositeReaderContext.cs
@@ -1,4 +1,5 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -69,7 +70,7 @@ namespace Lucene.Net.Index
                 {
                     throw new NotSupportedException("this is not a top-level context.");
                 }
-                Debug.Assert(leaves != null);
+                Debugging.Assert(() => leaves != null);
                 return leaves;
             }
         }
@@ -125,7 +126,7 @@ namespace Lucene.Net.Index
                         children[i] = Build(newParent, r, i, newDocBase);
                         newDocBase += r.MaxDoc;
                     }
-                    Debug.Assert(newDocBase == cr.MaxDoc);
+                    Debugging.Assert(() => newDocBase == cr.MaxDoc);
                     return newParent;
                 }
             }
diff --git a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
index 6be45ef..f394b4f 100644
--- a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
+++ b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs
@@ -394,7 +394,7 @@ namespace Lucene.Net.Index
         {
             lock (this)
             {
-                //Debug.Assert(!Thread.holdsLock(writer));
+                //Debugging.Assert(!Thread.holdsLock(writer));
 
                 this.m_writer = writer;
 
diff --git a/src/Lucene.Net/Index/DirectoryReader.cs b/src/Lucene.Net/Index/DirectoryReader.cs
index dd7f211..f34c2e5 100644
--- a/src/Lucene.Net/Index/DirectoryReader.cs
+++ b/src/Lucene.Net/Index/DirectoryReader.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -171,7 +172,7 @@ namespace Lucene.Net.Index
         public static DirectoryReader OpenIfChanged(DirectoryReader oldReader)
         {
             DirectoryReader newReader = oldReader.DoOpenIfChanged();
-            Debug.Assert(newReader != oldReader);
+            Debugging.Assert(() => newReader != oldReader);
             return newReader;
         }
 
@@ -184,7 +185,7 @@ namespace Lucene.Net.Index
         public static DirectoryReader OpenIfChanged(DirectoryReader oldReader, IndexCommit commit)
         {
             DirectoryReader newReader = oldReader.DoOpenIfChanged(commit);
-            Debug.Assert(newReader != oldReader);
+            Debugging.Assert(() => newReader != oldReader);
             return newReader;
         }
 
@@ -251,7 +252,7 @@ namespace Lucene.Net.Index
         public static DirectoryReader OpenIfChanged(DirectoryReader oldReader, IndexWriter writer, bool applyAllDeletes)
         {
             DirectoryReader newReader = oldReader.DoOpenIfChanged(writer, applyAllDeletes);
-            Debug.Assert(newReader != oldReader);
+            Debugging.Assert(() => newReader != oldReader);
             return newReader;
         }
 
diff --git a/src/Lucene.Net/Index/DocFieldProcessor.cs b/src/Lucene.Net/Index/DocFieldProcessor.cs
index 898776d..2cdce5e 100644
--- a/src/Lucene.Net/Index/DocFieldProcessor.cs
+++ b/src/Lucene.Net/Index/DocFieldProcessor.cs
@@ -1,4 +1,5 @@
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -79,7 +80,7 @@ namespace Lucene.Net.Index
                 childFields[f.FieldInfo.Name] = f;
             }
 
-            Debug.Assert(fields.Count == totalFieldCount);
+            Debugging.Assert(() => fields.Count == totalFieldCount);
 
             storedConsumer.Flush(state);
             consumer.Flush(childFields, state);
@@ -166,14 +167,14 @@ namespace Lucene.Net.Index
                     field = field.next;
                 }
             }
-            Debug.Assert(fields.Count == totalFieldCount);
+            Debugging.Assert(() => fields.Count == totalFieldCount);
             return fields;
         }
 
         private void Rehash()
         {
             int newHashSize = (fieldHash.Length * 2);
-            Debug.Assert(newHashSize > fieldHash.Length);
+            Debugging.Assert(() => newHashSize > fieldHash.Length);
 
             DocFieldProcessorPerField[] newHashArray = new DocFieldProcessorPerField[newHashSize];
 
@@ -246,7 +247,7 @@ namespace Lucene.Net.Index
                     // need to addOrUpdate so that FieldInfos can update globalFieldNumbers
                     // with the correct DocValue type (LUCENE-5192)
                     FieldInfo fi = fieldInfos.AddOrUpdate(fieldName, field.IndexableFieldType);
-                    Debug.Assert(fi == fp.fieldInfo, "should only have updated an existing FieldInfo instance");
+                    Debugging.Assert(() => fi == fp.fieldInfo, () => "should only have updated an existing FieldInfo instance");
                 }
 
                 if (thisFieldGen != fp.lastGen)
diff --git a/src/Lucene.Net/Index/DocTermOrds.cs b/src/Lucene.Net/Index/DocTermOrds.cs
index 638a68c..eaa41ca 100644
--- a/src/Lucene.Net/Index/DocTermOrds.cs
+++ b/src/Lucene.Net/Index/DocTermOrds.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -752,7 +753,7 @@ namespace Lucene.Net.Index
                 this.outerInstance = outerInstance;
 
                 InitializeInstanceFields();
-                Debug.Assert(outerInstance.m_indexedTermsArray != null);
+                Debugging.Assert(() => outerInstance.m_indexedTermsArray != null);
                 termsEnum = reader.Fields.GetTerms(outerInstance.m_field).GetIterator(null);
             }
 
@@ -804,10 +805,10 @@ namespace Lucene.Net.Index
                 {
                     // we hit the term exactly... lucky us!
                     TermsEnum.SeekStatus seekStatus = termsEnum.SeekCeil(target);
-                    Debug.Assert(seekStatus == TermsEnum.SeekStatus.FOUND);
... 10923 lines suppressed ...


[lucenenet] 05/13: Converted all test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()

Posted by ni...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git

commit a9eb0c8a714b801ede91bb1a32f456245d6c4d57
Author: Shad Storhaug <sh...@shadstorhaug.com>
AuthorDate: Thu Aug 13 23:31:25 2020 +0700

    Converted all test projects to use Lucene.Net.Diagnostics.Debugging.Assert() instead of System.Diagnostics.Debug.Assert()
---
 .../GraphvizFormatter.cs                           |  6 +--
 .../JapaneseIterationMarkCharFilter.cs             |  4 +-
 .../JapaneseTokenizer.cs                           | 38 +++++++-------
 .../Tools/BinaryDictionaryWriter.cs                | 11 ++--
 .../Tools/ConnectionCostsBuilder.cs                |  3 +-
 .../Analysis/CharFilters/TestMappingCharFilter.cs  |  6 +--
 .../Analysis/Core/TestFactories.cs                 |  4 +-
 .../Analysis/Core/TestRandomChains.cs              |  6 +--
 .../Analysis/Hunspell/TestAllDictionaries.cs       | 16 +++---
 .../Analysis/Hunspell/TestAllDictionaries2.cs      | 16 +++---
 .../Analysis/Synonym/TestSynonymMapFilter.cs       |  6 +--
 src/Lucene.Net.Tests.Facet/FacetTestCase.cs        |  6 +--
 .../Range/TestRangeFacetCounts.cs                  | 58 +++++++++++-----------
 .../Taxonomy/TestTaxonomyFacetSumValueSource.cs    |  6 +--
 src/Lucene.Net.Tests.Facet/TestDrillSideways.cs    |  8 +--
 .../GroupFacetCollectorTest.cs                     |  6 +--
 .../PostingsHighlight/TestPostingsHighlighter.cs   |  7 +--
 src/Lucene.Net.Tests.Join/TestJoinUtil.cs          |  4 +-
 .../Classic/TestQueryParser.cs                     | 18 +++----
 .../Flexible/Standard/TestStandardQP.cs            | 12 ++---
 .../IndexAndTaxonomyReplicationClientTest.cs       |  4 +-
 .../IndexReplicationClientTest.cs                  |  4 +-
 src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs    |  8 +--
 .../Suggest/Analyzing/AnalyzingSuggesterTest.cs    |  4 +-
 .../Suggest/Analyzing/FuzzySuggesterTest.cs        |  6 +--
 .../Suggest/Analyzing/TestFreeTextSuggester.cs     |  6 +--
 .../Suggest/LookupBenchmarkTest.cs                 |  6 +--
 .../Analysis/TestGraphTokenizers.cs                |  4 +-
 .../Codecs/Lucene41/TestBlockPostingsFormat3.cs    |  4 +-
 .../Codecs/PerField/TestPerFieldDocValuesFormat.cs |  4 +-
 .../Index/TestBackwardsCompatibility.cs            |  4 +-
 .../Index/TestBackwardsCompatibility3x.cs          |  4 +-
 src/Lucene.Net.Tests/Index/TestCodecs.cs           |  8 +--
 src/Lucene.Net.Tests/Index/TestIndexWriter.cs      |  7 ++-
 .../Index/TestIndexWriterMerging.cs                |  4 +-
 src/Lucene.Net.Tests/Index/TestIndexableField.cs   |  6 +--
 src/Lucene.Net.Tests/Index/TestLongPostings.cs     |  6 +--
 src/Lucene.Net.Tests/Index/TestNRTThreads.cs       |  4 +-
 src/Lucene.Net.Tests/Index/TestPayloads.cs         |  4 +-
 .../Index/TestPayloadsOnVectors.cs                 |  6 +--
 src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs  | 10 ++--
 src/Lucene.Net.Tests/Index/TestStressIndexing2.cs  |  6 +--
 src/Lucene.Net.Tests/Index/TestStressNRT.cs        |  6 +--
 src/Lucene.Net.Tests/Index/TestTermsEnum.cs        |  6 +--
 .../Search/Spans/MultiSpansWrapper.cs              |  4 +-
 src/Lucene.Net.Tests/Search/TestBooleanScorer.cs   |  4 +-
 .../Search/TestConstantScoreQuery.cs               |  4 +-
 src/Lucene.Net.Tests/Search/TestFieldCache.cs      | 48 +++++++++---------
 src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs | 16 +++---
 .../Search/TestMultiThreadTermVectors.cs           |  4 +-
 .../Search/TestNumericRangeQuery32.cs              |  8 +--
 .../Search/TestNumericRangeQuery64.cs              |  6 +--
 .../Search/TestTimeLimitingCollector.cs            |  4 +-
 .../Util/Automaton/TestUTF32ToUTF8.cs              |  8 +--
 src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs          |  4 +-
 .../Util/Packed/TestEliasFanoDocIdSet.cs           |  4 +-
 .../Util/Packed/TestEliasFanoSequence.cs           |  8 +--
 src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs      |  4 +-
 src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs      |  4 +-
 .../TestICUPostingsHighlighter.cs                  |  8 +--
 60 files changed, 251 insertions(+), 259 deletions(-)

diff --git a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
index a1e1fa9..aca253c 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/GraphvizFormatter.cs
@@ -1,7 +1,7 @@
 using Lucene.Net.Analysis.Ja.Dict;
+using Lucene.Net.Diagnostics;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Text;
 
 namespace Lucene.Net.Analysis.Ja
@@ -89,8 +89,8 @@ namespace Lucene.Net.Analysis.Ja
                 string toNodeID = GetNodeID(pos, bestIDX);
                 string fromNodeID = GetNodeID(backPos, backIDX);
 
-                Debugging.Assert(!bestPathMap.ContainsKey(fromNodeID));
-                Debugging.Assert(!bestPathMap.Values.Contains(toNodeID));
+                Debugging.Assert(() => !bestPathMap.ContainsKey(fromNodeID));
+                Debugging.Assert(() => !bestPathMap.Values.Contains(toNodeID));
                 bestPathMap[fromNodeID] = toNodeID;
                 pos = backPos;
                 bestIDX = backIDX;
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
index ad243f4..931d70e 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseIterationMarkCharFilter.cs
@@ -1,5 +1,5 @@
 using Lucene.Net.Analysis.Util;
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 using System.IO;
 
 namespace Lucene.Net.Analysis.Ja
@@ -133,7 +133,7 @@ namespace Lucene.Net.Analysis.Ja
 
             // Make katakana dakuten map from hiragana map
             char codePointDifference = (char)('\u30ab' - '\u304b'); // カ - か
-            Debugging.Assert(h2d.Length == k2d.Length);
+            Debugging.Assert(() => h2d.Length == k2d.Length);
             for (int i = 0; i < k2d.Length; i++)
             {
                 k2d[i] = (char)(h2d[i] + codePointDifference);
diff --git a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
index d9d2293..2d3c993 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/JapaneseTokenizer.cs
@@ -3,11 +3,11 @@ using Lucene.Net.Analysis.Ja.Dict;
 using Lucene.Net.Analysis.Ja.TokenAttributes;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Fst;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Threading;
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis.Ja
             int leftID = dict.GetLeftId(wordID);
             int leastCost = int.MaxValue;
             int leastIDX = -1;
-            Debugging.Assert(fromPosData.count > 0);
+            Debugging.Assert(() => fromPosData.count > 0);
             for (int idx = 0; idx < fromPosData.count; idx++)
             {
                 // Cost is path cost so far, plus word cost (added at
@@ -356,7 +356,7 @@ namespace Lucene.Net.Analysis.Ja
             }
 
             //positions.get(endPos).add(leastCost, dict.getRightId(wordID), fromPosData.pos, leastIDX, wordID, type);
-            Debugging.Assert(leftID == dict.GetRightId(wordID));
+            Debugging.Assert(() => leftID == dict.GetRightId(wordID));
             positions.Get(endPos).Add(leastCost, leftID, fromPosData.pos, leastIDX, wordID, type);
         }
 
@@ -387,7 +387,7 @@ namespace Lucene.Net.Analysis.Ja
             int position = token.Position;
             int length = token.Length;
             ClearAttributes();
-            Debugging.Assert(length > 0);
+            Debugging.Assert(() => length > 0);
             //System.out.println("off=" + token.getOffset() + " len=" + length + " vs " + token.getSurfaceForm().length);
             termAtt.CopyBuffer(token.SurfaceForm, token.Offset, length);
             offsetAtt.SetOffset(CorrectOffset(position), CorrectOffset(position + length));
@@ -402,7 +402,7 @@ namespace Lucene.Net.Analysis.Ja
             }
             else
             {
-                Debugging.Assert(token.Position > lastTokenPos);
+                Debugging.Assert(() => token.Position > lastTokenPos);
                 posIncAtt.PositionIncrement = 1;
                 posLengthAtt.PositionLength = 1;
             }
@@ -511,7 +511,7 @@ namespace Lucene.Net.Analysis.Ja
                     }
 
                     // We will always have at least one live path:
-                    Debugging.Assert(leastIDX != -1);
+                    Debugging.Assert(() => leastIDX != -1);
 
                     // Second pass: prune all but the best path:
                     for (int pos2 = pos; pos2 < positions.GetNextPos(); pos2++)
@@ -544,7 +544,7 @@ namespace Lucene.Net.Analysis.Ja
                     if (pos != leastPosData.pos)
                     {
                         // We jumped into a future position:
-                        Debugging.Assert(pos < leastPosData.pos);
+                        Debugging.Assert(() => pos < leastPosData.pos);
                         pos = leastPosData.pos;
                     }
 
@@ -913,10 +913,10 @@ namespace Lucene.Net.Analysis.Ja
             {
                 //System.out.println("BT: back pos=" + pos + " bestIDX=" + bestIDX);
                 Position posData = positions.Get(pos);
-                Debugging.Assert(bestIDX < posData.count);
+                Debugging.Assert(() => bestIDX < posData.count);
 
                 int backPos = posData.backPos[bestIDX];
-                Debugging.Assert(backPos >= lastBackTracePos, "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
+                Debugging.Assert(() => backPos >= lastBackTracePos, () => "backPos=" + backPos + " vs lastBackTracePos=" + lastBackTracePos);
                 int length = pos - backPos;
                 JapaneseTokenizerType backType = posData.backType[bestIDX];
                 int backID = posData.backID[bestIDX];
@@ -989,7 +989,7 @@ namespace Lucene.Net.Analysis.Ja
                         if (leastIDX != -1 && leastCost <= maxCost && posData.backPos[leastIDX] != backPos)
                         {
                             // We should have pruned the altToken from the graph:
-                            Debugging.Assert(posData.backPos[leastIDX] != backPos);
+                            Debugging.Assert(() => posData.backPos[leastIDX] != backPos);
 
                             // Save the current compound token, to output when
                             // this alternate path joins back:
@@ -1024,7 +1024,7 @@ namespace Lucene.Net.Analysis.Ja
                 }
 
                 int offset = backPos - lastBackTracePos;
-                Debugging.Assert(offset >= 0);
+                Debugging.Assert(() => offset >= 0);
 
                 if (altToken != null && altToken.Position >= backPos)
                 {
@@ -1035,7 +1035,7 @@ namespace Lucene.Net.Analysis.Ja
                     // The pruning we did when we created the altToken
                     // ensures that the back trace will align back with
                     // the start of the altToken:
-                    Debugging.Assert(altToken.Position == backPos, altToken.Position + " vs " + backPos);
+                    Debugging.Assert(() => altToken.Position == backPos, () => altToken.Position + " vs " + backPos);
 
                     // NOTE: not quite right: the compound token may
                     // have had all punctuation back traced so far, but
@@ -1060,7 +1060,7 @@ namespace Lucene.Net.Analysis.Ja
                         {
                             Console.WriteLine("    discard all-punctuation altToken=" + altToken);
                         }
-                        Debugging.Assert(discardPunctuation);
+                        Debugging.Assert(() => discardPunctuation);
                     }
                     altToken = null;
                 }
@@ -1355,7 +1355,7 @@ namespace Lucene.Net.Analysis.Ja
         {
             count = 0;
             // forwardCount naturally resets after it runs:
-            Debugging.Assert(forwardCount == 0, "pos=" + pos + " forwardCount=" + forwardCount);
+            Debugging.Assert(() => forwardCount == 0, () => "pos=" + pos + " forwardCount=" + forwardCount);
         }
     }
 
@@ -1432,13 +1432,13 @@ namespace Lucene.Net.Analysis.Ja
                     nextWrite = 0;
                 }
                 // Should have already been reset:
-                Debugging.Assert(positions[nextWrite].count == 0);
+                Debugging.Assert(() => positions[nextWrite].count == 0);
                 positions[nextWrite++].pos = nextPos++;
                 count++;
             }
-            Debugging.Assert(InBounds(pos));
+            Debugging.Assert(() => InBounds(pos));
             int index = GetIndex(pos);
-            Debugging.Assert(positions[index].pos == pos);
+            Debugging.Assert(() => positions[index].pos == pos);
             return positions[index];
         }
 
@@ -1466,8 +1466,8 @@ namespace Lucene.Net.Analysis.Ja
         public void FreeBefore(int pos)
         {
             int toFree = count - (nextPos - pos);
-            Debugging.Assert(toFree >= 0);
-            Debugging.Assert(toFree <= count);
+            Debugging.Assert(() => toFree >= 0);
+            Debugging.Assert(() => toFree <= count);
             int index = nextWrite - count;
             if (index < 0)
             {
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
index cfbfb3d..ecb270d 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/BinaryDictionaryWriter.cs
@@ -6,7 +6,6 @@ using Lucene.Net.Store;
 using Lucene.Net.Util;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
@@ -62,7 +61,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             for (int i = 4; i < 8; i++)
             {
                 string part = entry[i];
-                Debugging.Assert(part.Length > 0);
+                Debugging.Assert(() => part.Length > 0);
                 if (!"*".Equals(part, StringComparison.Ordinal))
                 {
                     if (sb.Length > 0)
@@ -119,8 +118,8 @@ namespace Lucene.Net.Analysis.Ja.Util
                 flags |= BinaryDictionary.HAS_PRONUNCIATION;
             }
 
-            Debugging.Assert(leftId == rightId);
-            Debugging.Assert(leftId < 4096); // there are still unused bits
+            Debugging.Assert(() => leftId == rightId);
+            Debugging.Assert(() => leftId < 4096); // there are still unused bits
                                          // add pos mapping
             int toFill = 1 + leftId - posDict.Count;
             for (int i = 0; i < toFill; i++)
@@ -129,7 +128,7 @@ namespace Lucene.Net.Analysis.Ja.Util
             }
 
             string existing = posDict[leftId];
-            Debugging.Assert(existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
+            Debugging.Assert(() => existing == null || existing.Equals(fullPOSData, StringComparison.Ordinal));
             posDict[leftId] = fullPOSData;
 
             m_buffer.PutInt16((short)(leftId << 3 | flags));
@@ -137,7 +136,7 @@ namespace Lucene.Net.Analysis.Ja.Util
 
             if ((flags & BinaryDictionary.HAS_BASEFORM) != 0)
             {
-                Debugging.Assert(baseForm.Length < 16);
+                Debugging.Assert(() => baseForm.Length < 16);
                 int shared = SharedPrefix(entry[0], baseForm);
                 int suffix = baseForm.Length - shared;
                 m_buffer.Put((byte)(shared << 4 | suffix));
diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
index d7acc77..a653cdc 100644
--- a/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
+++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/ConnectionCostsBuilder.cs
@@ -1,6 +1,5 @@
 using J2N.Text;
 using Lucene.Net.Diagnostics;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
@@ -55,7 +54,7 @@ namespace Lucene.Net.Analysis.Ja.Util
                 {
                     string[] fields = whiteSpaceRegex.Split(line).TrimEnd();
 
-                    Debugging.Assert(fields.Length == 3);
+                    Debugging.Assert(() => fields.Length == 3);
 
                     int forwardId = int.Parse(fields[0], CultureInfo.InvariantCulture);
                     int backwardId = int.Parse(fields[1], CultureInfo.InvariantCulture);
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
index b694a36..f398ac1 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/CharFilters/TestMappingCharFilter.cs
@@ -1,8 +1,8 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -422,7 +422,7 @@ namespace Lucene.Net.Analysis.CharFilters
                                 // Same length: no change to offset
                             }
 
-                            Debug.Assert(inputOffsets.Count == output.Length, "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
+                            Debugging.Assert(() => inputOffsets.Count == output.Length, () => "inputOffsets.size()=" + inputOffsets.Count + " vs output.length()=" + output.Length);
                         }
                         else
                         {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
index fc004ee..e48cafa 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 
@@ -211,7 +211,7 @@ namespace Lucene.Net.Analysis.Core
 
             internal FactoryAnalyzer(TokenizerFactory tokenizer, TokenFilterFactory tokenfilter, CharFilterFactory charFilter)
             {
-                Debug.Assert(tokenizer != null);
+                Debugging.Assert(() => tokenizer != null);
                 this.tokenizer = tokenizer;
                 this.charFilter = charFilter;
                 this.tokenfilter = tokenfilter;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
index b71771b..4f66f90 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
@@ -17,6 +17,7 @@ using Lucene.Net.Analysis.Standard;
 using Lucene.Net.Analysis.Synonym;
 using Lucene.Net.Analysis.Util;
 using Lucene.Net.Analysis.Wikipedia;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Tartarus.Snowball;
 using Lucene.Net.TestFramework.Analysis;
@@ -25,7 +26,6 @@ using Lucene.Net.Util.Automaton;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -172,7 +172,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                Debug.Assert(args.Length == 3);
+                Debugging.Assert(() => args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
@@ -185,7 +185,7 @@ namespace Lucene.Net.Analysis.Core
 
             public virtual bool Apply(object[] args)
             {
-                Debug.Assert(args.Length == 3);
+                Debugging.Assert(() => args.Length == 3);
                 return !((bool)args[2]); // args are broken if consumeAllTokens is false
             }
         }
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
index 657ef71..b8158af 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries.cs
@@ -1,7 +1,7 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
 using System.Text;
@@ -168,16 +168,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                Debug.Assert(f.Exists);
+                Debugging.Assert(() => f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        Debug.Assert(dicEntry != null);
+                        Debugging.Assert(() => dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        Debug.Assert(affEntry != null);
+                        Debugging.Assert(() => affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -208,16 +208,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    Debug.Assert(f.Exists);
+                    Debugging.Assert(() => f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            Debug.Assert(dicEntry != null);
+                            Debugging.Assert(() => dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            Debug.Assert(affEntry != null);
+                            Debugging.Assert(() => affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
index 2a60fc5..e6c2d97 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Hunspell/TestAllDictionaries2.cs
@@ -1,7 +1,7 @@
-using Lucene.Net.Util;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
 using System.Text;
@@ -184,16 +184,16 @@ namespace Lucene.Net.Analysis.Hunspell
             for (int i = 0; i < tests.Length; i += 3)
             {
                 FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                Debug.Assert(f.Exists);
+                Debugging.Assert(() => f.Exists);
 
                 using (Stream fileStream = f.OpenRead())
                 {
                     using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                     {
                         ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                        Debug.Assert(dicEntry != null);
+                        Debugging.Assert(() => dicEntry != null);
                         ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                        Debug.Assert(affEntry != null);
+                        Debugging.Assert(() => affEntry != null);
 
                         using (Stream dictionary = dicEntry.Open())
                         {
@@ -226,16 +226,16 @@ namespace Lucene.Net.Analysis.Hunspell
                 if (tests[i].Equals(toTest, StringComparison.Ordinal))
                 {
                     FileInfo f = new FileInfo(System.IO.Path.Combine(DICTIONARY_HOME.FullName, tests[i]));
-                    Debug.Assert(f.Exists);
+                    Debugging.Assert(() => f.Exists);
 
                     using (Stream fileStream = f.OpenRead())
                     {
                         using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Read, false, Encoding.UTF8))
                         {
                             ZipArchiveEntry dicEntry = zip.GetEntry(tests[i + 1]);
-                            Debug.Assert(dicEntry != null);
+                            Debugging.Assert(() => dicEntry != null);
                             ZipArchiveEntry affEntry = zip.GetEntry(tests[i + 2]);
-                            Debug.Assert(affEntry != null);
+                            Debugging.Assert(() => affEntry != null);
 
                             using (Stream dictionary = dicEntry.Open())
                             {
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
index 432fd22..4ec4e7d 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMapFilter.cs
@@ -1,18 +1,18 @@
 using J2N.Text;
 using Lucene.Net.Analysis.Core;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
-using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
+using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Analysis.Synonym
 {
@@ -268,7 +268,7 @@ namespace Lucene.Net.Analysis.Synonym
 
         private string GetRandomString(char start, int alphabetSize, int length)
         {
-            Debug.Assert(alphabetSize <= 26);
+            Debugging.Assert(() => alphabetSize <= 26);
             char[] s = new char[2 * length];
             for (int charIDX = 0; charIDX < length; charIDX++)
             {
diff --git a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
index fd04d81..7c7a4ef 100644
--- a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
+++ b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs
@@ -1,8 +1,8 @@
-using Lucene.Net.Support;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -154,7 +154,7 @@ namespace Lucene.Net.Facet
                     if (numInRow > 1)
                     {
                         Array.Sort(labelValues, i - numInRow, i - (i - numInRow), Comparer<LabelAndValue>.Create((a,b)=> {
-                            Debug.Assert((double)a.Value == (double)b.Value);
+                            Debugging.Assert(() => (double)a.Value == (double)b.Value);
                             return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label));
                         }));
                     }
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index 32b9588..a28559c 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -1,9 +1,10 @@
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
+using Lucene.Net.Search;
+using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Collections;
 using System.Collections.Generic;
-using NUnit.Framework;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -27,43 +28,40 @@ namespace Lucene.Net.Facet.Range
      * limitations under the License.
      */
 
-
-    using Document = Lucene.Net.Documents.Document;
-    using DoubleDocValuesField = Lucene.Net.Documents.DoubleDocValuesField;
-    using DoubleField = Lucene.Net.Documents.DoubleField;
-    using Field = Lucene.Net.Documents.Field;
-    using SingleDocValuesField = Lucene.Net.Documents.SingleDocValuesField;
-    using SingleField = Lucene.Net.Documents.SingleField;
-    using Int64Field = Lucene.Net.Documents.Int64Field;
-    using NumericDocValuesField = Lucene.Net.Documents.NumericDocValuesField;
-    using DrillSidewaysResult = Lucene.Net.Facet.DrillSidewaysResult;
-    using TaxonomyReader = Lucene.Net.Facet.Taxonomy.TaxonomyReader;
-    using DirectoryTaxonomyReader = Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader;
-    using DirectoryTaxonomyWriter = Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter;
     using AtomicReader = Lucene.Net.Index.AtomicReader;
     using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
-    using IndexReader = Lucene.Net.Index.IndexReader;
-    using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig;
-    using OpenMode = Lucene.Net.Index.OpenMode;
-    using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
-    using FunctionValues = Lucene.Net.Queries.Function.FunctionValues;
-    using ValueSource = Lucene.Net.Queries.Function.ValueSource;
-    using DoubleDocValues = Lucene.Net.Queries.Function.DocValues.DoubleDocValues;
-    using DoubleFieldSource = Lucene.Net.Queries.Function.ValueSources.DoubleFieldSource;
-    using SingleFieldSource = Lucene.Net.Queries.Function.ValueSources.SingleFieldSource;
-    using Int64FieldSource = Lucene.Net.Queries.Function.ValueSources.Int64FieldSource;
     using CachingWrapperFilter = Lucene.Net.Search.CachingWrapperFilter;
+    using Directory = Lucene.Net.Store.Directory;
+    using DirectoryTaxonomyReader = Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader;
+    using DirectoryTaxonomyWriter = Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter;
     using DocIdSet = Lucene.Net.Search.DocIdSet;
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
+    using Document = Lucene.Net.Documents.Document;
+    using DoubleDocValues = Lucene.Net.Queries.Function.DocValues.DoubleDocValues;
+    using DoubleDocValuesField = Lucene.Net.Documents.DoubleDocValuesField;
+    using DoubleField = Lucene.Net.Documents.DoubleField;
+    using DoubleFieldSource = Lucene.Net.Queries.Function.ValueSources.DoubleFieldSource;
+    using DrillSidewaysResult = Lucene.Net.Facet.DrillSidewaysResult;
+    using Field = Lucene.Net.Documents.Field;
     using Filter = Lucene.Net.Search.Filter;
+    using FixedBitSet = Lucene.Net.Util.FixedBitSet;
+    using FunctionValues = Lucene.Net.Queries.Function.FunctionValues;
+    using IndexReader = Lucene.Net.Index.IndexReader;
     using IndexSearcher = Lucene.Net.Search.IndexSearcher;
+    using Int64Field = Lucene.Net.Documents.Int64Field;
+    using Int64FieldSource = Lucene.Net.Queries.Function.ValueSources.Int64FieldSource;
+    using IOUtils = Lucene.Net.Util.IOUtils;
     using MatchAllDocsQuery = Lucene.Net.Search.MatchAllDocsQuery;
-    using Lucene.Net.Search;
+    using NumericDocValuesField = Lucene.Net.Documents.NumericDocValuesField;
+    using OpenMode = Lucene.Net.Index.OpenMode;
     using QueryWrapperFilter = Lucene.Net.Search.QueryWrapperFilter;
-    using Directory = Lucene.Net.Store.Directory;
-    using FixedBitSet = Lucene.Net.Util.FixedBitSet;
-    using IOUtils = Lucene.Net.Util.IOUtils;
+    using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
+    using SingleDocValuesField = Lucene.Net.Documents.SingleDocValuesField;
+    using SingleField = Lucene.Net.Documents.SingleField;
+    using SingleFieldSource = Lucene.Net.Queries.Function.ValueSources.SingleFieldSource;
+    using TaxonomyReader = Lucene.Net.Facet.Taxonomy.TaxonomyReader;
     using TestUtil = Lucene.Net.Util.TestUtil;
+    using ValueSource = Lucene.Net.Queries.Function.ValueSource;
 
     [TestFixture]
     public class TestRangeFacetCounts : FacetTestCase
@@ -1199,7 +1197,7 @@ namespace Lucene.Net.Facet.Range
 
             protected override Facets BuildFacetsResult(FacetsCollector drillDowns, FacetsCollector[] drillSideways, string[] drillSidewaysDims)
             {
-                Debug.Assert(drillSideways.Length == 1);
+                Debugging.Assert(() => drillSideways.Length == 1);
                 return new DoubleRangeFacetCounts("field", vs, drillSideways[0], fastMatchFilter, ranges);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
index 254c9a5..6e8be41 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
@@ -1,8 +1,8 @@
-using NUnit.Framework;
+using Lucene.Net.Diagnostics;
+using NUnit.Framework;
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using Assert = Lucene.Net.TestFramework.Assert;
@@ -385,7 +385,7 @@ namespace Lucene.Net.Facet.Taxonomy
             public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
             {
                 Scorer scorer = (Scorer)context["scorer"];
-                Debug.Assert(scorer != null);
+                Debugging.Assert(() => scorer != null);
                 return new DoubleDocValuesAnonymousInnerClassHelper(this, scorer);
             }
 
diff --git a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
index 31630d4..115a120 100644
--- a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
+++ b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
@@ -1,11 +1,11 @@
 using J2N.Collections.Generic.Extensions;
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -866,7 +866,7 @@ namespace Lucene.Net.Facet
 
             public virtual void Collect(int doc)
             {
-                Debug.Assert(doc > lastDocID);
+                Debugging.Assert(() => doc > lastDocID);
                 lastDocID = doc;
             }
 
@@ -948,8 +948,8 @@ namespace Lucene.Net.Facet
 
             public virtual void Inc(int[] dims, int[] dims2, int onlyDim)
             {
-                Debug.Assert(dims.Length == counts.Length);
-                Debug.Assert(dims2.Length == counts.Length);
+                Debugging.Assert(() => dims.Length == counts.Length);
+                Debugging.Assert(() => dims2.Length == counts.Length);
                 for (int dim = 0; dim < dims.Length; dim++)
                 {
                     if (onlyDim == -1 || dim == onlyDim)
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index ba3bbba..faa1519 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -1,6 +1,7 @@
 using J2N;
 using J2N.Text;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -10,7 +11,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using Collections = Lucene.Net.Support.Collections;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -559,7 +559,7 @@ namespace Lucene.Net.Search.Grouping
             Field[] facetFields;
             if (useDv)
             {
-                Debug.Assert(!multipleFacetValuesPerDocument);
+                Debugging.Assert(() => !multipleFacetValuesPerDocument);
                 facetFields = new Field[2];
                 facetFields[0] = NewStringField("facet", "", Field.Store.NO);
                 doc.Add(facetFields[0]);
@@ -816,7 +816,7 @@ namespace Lucene.Net.Search.Grouping
         {
             BytesRef facetPrefixBR = facetPrefix == null ? null : new BytesRef(facetPrefix);
             // DocValues cannot be multi-valued:
-            Debug.Assert(!multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
+            Debugging.Assert(() => !multipleFacetsPerDocument || !groupField.EndsWith("_dv", StringComparison.Ordinal));
             return TermGroupFacetCollector.CreateTermGroupFacetCollector(groupField, facetField, multipleFacetsPerDocument, facetPrefixBR, Random.nextInt(1024));
         }
 
diff --git a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
index 08ebb86..859bff4 100644
--- a/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
+++ b/src/Lucene.Net.Tests.Highlighter/PostingsHighlight/TestPostingsHighlighter.cs
@@ -1,6 +1,7 @@
 #if FEATURE_BREAKITERATOR
 using ICU4N.Text;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -774,8 +775,8 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             protected override IList<string[]> LoadFieldValues(IndexSearcher searcher, string[] fields, int[] docids, int maxLength)
             {
-                Debug.Assert(fields.Length == 1);
-                Debug.Assert(docids.Length == 1);
+                Debugging.Assert(() => fields.Length == 1);
+                Debugging.Assert(() => docids.Length == 1);
                 String[][] contents = RectangularArrays.ReturnRectangularArray<string>(1, 1); //= new String[1][1];
                 contents[0][0] = text;
                 return contents;
@@ -1178,7 +1179,7 @@ namespace Lucene.Net.Search.PostingsHighlight
         {
             protected override char GetMultiValuedSeparator(string field)
             {
-                Debug.Assert(field.Equals("body", StringComparison.Ordinal));
+                Debugging.Assert(() => field.Equals("body", StringComparison.Ordinal));
                 return '\u2029';
             }
         }
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index a52fa62..f79246d 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -9,7 +10,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using Console = Lucene.Net.Util.SystemConsole;
 using JCG = J2N.Collections.Generic;
 
@@ -1030,7 +1030,7 @@ namespace Lucene.Net.Tests.Join
                     {
                         DocsEnum docsEnum = MultiFields.GetTermDocsEnum(topLevelReader,
                             MultiFields.GetLiveDocs(topLevelReader), "id", new BytesRef(otherSideDoc.id), 0);
-                        Debug.Assert(docsEnum != null);
+                        Debugging.Assert(() => docsEnum != null);
                         int doc = docsEnum.NextDoc();
                         expectedResult.Set(doc);
                     }
diff --git a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
index 60027b9..10bffe2 100644
--- a/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Classic/TestQueryParser.cs
@@ -1,15 +1,13 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.QueryParsers.Flexible.Standard;
 using Lucene.Net.QueryParsers.Util;
 using Lucene.Net.Search;
-using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Globalization;
-using System.Reflection;
 
 namespace Lucene.Net.QueryParsers.Classic
 {
@@ -67,8 +65,8 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override Query GetQuery(string query, ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC != null, "Parameter must not be null");
-            Debug.Assert(cqpC is QueryParser, "Parameter must be instance of QueryParser");
+            Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
+            Debugging.Assert(() => cqpC is QueryParser, () => "Parameter must be instance of QueryParser");
             QueryParser qp = (QueryParser)cqpC;
             return qp.Parse(query);
         }
@@ -85,35 +83,35 @@ namespace Lucene.Net.QueryParsers.Classic
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC is QueryParser);
+            Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.OR;
         }
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC is QueryParser);
+            Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.DefaultOperator = Operator.AND;
         }
 
         public override void SetAnalyzeRangeTerms(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            Debug.Assert(cqpC is QueryParser);
+            Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AnalyzeRangeTerms = (value);
         }
 
         public override void SetAutoGeneratePhraseQueries(ICommonQueryParserConfiguration cqpC, bool value)
         {
-            Debug.Assert(cqpC is QueryParser);
+            Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.AutoGeneratePhraseQueries = value;
         }
 
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC, string field, DateTools.Resolution value)
         {
-            Debug.Assert(cqpC is QueryParser);
+            Debugging.Assert(() => cqpC is QueryParser);
             QueryParser qp = (QueryParser)cqpC;
             qp.SetDateResolution(field, value);
         }
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
index d81dcf4..c336603 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Standard/TestStandardQP.cs
@@ -1,4 +1,5 @@
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.QueryParsers.Flexible.Core;
@@ -8,7 +9,6 @@ using Lucene.Net.Search;
 using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using Operator = Lucene.Net.QueryParsers.Flexible.Standard.Config.StandardQueryConfigHandler.Operator;
 
@@ -59,8 +59,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override Query GetQuery(String query, ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC != null, "Parameter must not be null");
-            Debug.Assert((cqpC is StandardQueryParser), "Parameter must be instance of StandardQueryParser");
+            Debugging.Assert(() => cqpC != null, () => "Parameter must not be null");
+            Debugging.Assert(() => (cqpC is StandardQueryParser), () => "Parameter must be instance of StandardQueryParser");
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             return Parse(query, qp);
         }
@@ -80,7 +80,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorOR(ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC is StandardQueryParser);
+            Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.OR);
         }
@@ -88,7 +88,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         public override void SetDefaultOperatorAND(ICommonQueryParserConfiguration cqpC)
         {
-            Debug.Assert(cqpC is StandardQueryParser);
+            Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DefaultOperator = (Operator.AND);
         }
@@ -111,7 +111,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         public override void SetDateResolution(ICommonQueryParserConfiguration cqpC,
             string field, DateTools.Resolution value)
         {
-            Debug.Assert(cqpC is StandardQueryParser);
+            Debugging.Assert(() => cqpC is StandardQueryParser);
             StandardQueryParser qp = (StandardQueryParser)cqpC;
             qp.DateResolutionMap.Put(field, value);
         }
diff --git a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
index 69c5b03..b41b01a 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
@@ -1,5 +1,6 @@
 using J2N.Threading.Atomic;
 using Lucene.Net.Attributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Facet;
 using Lucene.Net.Facet.Taxonomy;
@@ -11,7 +12,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Threading;
@@ -461,7 +461,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        Debug.Assert(failures >= 0, "handler failed too many times: " + failures);
+                        Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
index c313fdb..3c158bf 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
@@ -1,5 +1,6 @@
 using J2N.Threading.Atomic;
 using Lucene.Net.Attributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Store;
@@ -7,7 +8,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Threading;
@@ -367,7 +367,7 @@ namespace Lucene.Net.Replicator
                     {
                         // count-down number of failures
                         failures.DecrementAndGet();
-                        Debug.Assert(failures >= 0, "handler failed too many times: " + failures);
+                        Debugging.Assert(() => failures >= 0, () => "handler failed too many times: " + failures);
                         if (Verbose)
                         {
                             if (failures == 0)
diff --git a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
index f34380c..b57d7fa 100644
--- a/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
+++ b/src/Lucene.Net.Tests.Spatial/SpatialTestCase.cs
@@ -1,5 +1,6 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Codecs.Lucene45;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -9,7 +10,6 @@ using Spatial4n.Core.Context;
 using Spatial4n.Core.Shapes;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 
@@ -152,7 +152,7 @@ namespace Lucene.Net.Spatial
 
         private double randomGaussianMinMeanMax(double min, double mean, double max)
         {
-            Debug.Assert(mean > min);
+            Debugging.Assert(() => mean > min);
             return randomGaussianMeanMax(mean - min, max - min) + min;
         }
 
@@ -166,7 +166,7 @@ namespace Lucene.Net.Spatial
         private double randomGaussianMeanMax(double mean, double max)
         {
             // DWS: I verified the results empirically
-            Debug.Assert(mean <= max && mean >= 0);
+            Debugging.Assert(() => mean <= max && mean >= 0);
             double g = randomGaussian();
             double mean2 = mean;
             double flip = 1;
@@ -180,7 +180,7 @@ namespace Lucene.Net.Spatial
             // 1 standard deviation alters the calculation
             double pivotMax = max - mean2;
             double pivot = Math.Min(mean2, pivotMax / 2);//from 0 to max-mean2
-            Debug.Assert(pivot >= 0 && pivotMax >= pivot && g >= 0);
+            Debugging.Assert(() => pivot >= 0 && pivotMax >= pivot && g >= 0);
             double pivotResult;
             if (g <= 1)
                 pivotResult = pivot * g;
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
index 27a6954..016b78e 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/AnalyzingSuggesterTest.cs
@@ -2,12 +2,12 @@
 using J2N.Text;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -651,7 +651,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    Debug.Assert(false);
+                    Debugging.Assert(() => false);
                     return 0;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
index c56e61b..5951a30 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
@@ -3,13 +3,13 @@ using J2N.Collections.Generic.Extensions;
 using J2N.Text;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using Lucene.Net.Util.Automaton;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
@@ -603,7 +603,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
                 else
                 {
-                    Debug.Assert(false);
+                    Debugging.Assert(() => false);
                     return 0;
                 }
             }
@@ -1313,7 +1313,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 else
                 {
                     int c = CHARSEQUENCE_COMPARER.Compare(a.Key, b.Key);
-                    Debug.Assert(c != 0, "term=" + a.Key);
+                    Debugging.Assert(() => c != 0, () => "term=" + a.Key);
                     return c;
                 }
             }
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
index bbe4e8a..2f160a6 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
@@ -2,18 +2,18 @@
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.Core;
 using Lucene.Net.Analysis.Util;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
-using JCG = J2N.Collections.Generic;
 using Console = Lucene.Net.Util.SystemConsole;
+using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Search.Suggest.Analyzing
 {
@@ -680,7 +680,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     return tokens[k];
                 }
             }
-            Debug.Assert(false);
+            Debugging.Assert(() => false);
             return null;
         }
 
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
index 15094cc..d835cf9 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/LookupBenchmarkTest.cs
@@ -1,6 +1,7 @@
 using J2N;
 using J2N.Collections.Generic.Extensions;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search.Suggest.Analyzing;
 using Lucene.Net.Search.Suggest.Fst;
 using Lucene.Net.Search.Suggest.Jaspell;
@@ -11,7 +12,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -75,7 +75,7 @@ namespace Lucene.Net.Search.Suggest
 
         public override void SetUp()
         {
-            Debug.Assert(false, "disable assertions before running benchmarks!");
+            Debugging.Assert(() => false, () => "disable assertions before running benchmarks!");
             IList<Input> input = ReadTop50KWiki();
             input.Shuffle(Random);
             dictionaryInput = input.ToArray();
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Suggest
             List<Input> input = new List<Input>();
 
             var resource = typeof(LookupBenchmarkTest).FindAndGetManifestResourceStream("Top50KWiki.utf8");
-            Debug.Assert(resource != null, "Resource missing: Top50KWiki.utf8");
+            Debugging.Assert(() => resource != null, () => "Resource missing: Top50KWiki.utf8");
 
             string line = null;
             using (TextReader br = new StreamReader(resource, UTF_8))
diff --git a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
index 8f912d2..8aaa6b9 100644
--- a/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestGraphTokenizers.cs
@@ -1,9 +1,9 @@
 using J2N.Text;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using Assert = Lucene.Net.TestFramework.Assert;
@@ -176,7 +176,7 @@ namespace Lucene.Net.Analysis
                     pos += minPosLength;
                     offset = 2 * pos;
                 }
-                Debug.Assert(maxPos <= pos, "input string mal-formed: posLength>1 tokens hang over the end");
+                Debugging.Assert(() => maxPos <= pos, () => "input string mal-formed: posLength>1 tokens hang over the end");
             }
         }
 
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
index a1478fd..6a2347d 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
@@ -1,5 +1,6 @@
 using J2N.Collections.Generic.Extensions;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -7,7 +8,6 @@ using Lucene.Net.Util.Automaton;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using JCG = J2N.Collections.Generic;
 
@@ -296,7 +296,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// </summary>
         public virtual void AssertTermsStatistics(Terms leftTerms, Terms rightTerms)
         {
-            Debug.Assert(leftTerms.Comparer == rightTerms.Comparer);
+            Debugging.Assert(() => leftTerms.Comparer == rightTerms.Comparer);
             if (leftTerms.DocCount != -1 && rightTerms.DocCount != -1)
             {
                 Assert.AreEqual(leftTerms.DocCount, rightTerms.DocCount);
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
index 51c479f..42a0bd8 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
@@ -1,10 +1,10 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 
 namespace Lucene.Net.Codecs.PerField
@@ -113,7 +113,7 @@ namespace Lucene.Net.Codecs.PerField
             {
                 Document hitDoc = isearcher.Doc(hits.ScoreDocs[i].Doc);
                 Assert.AreEqual(text, hitDoc.Get("fieldname"));
-                Debug.Assert(ireader.Leaves.Count == 1);
+                Debugging.Assert(() => ireader.Leaves.Count == 1);
                 NumericDocValues dv = ((AtomicReader)ireader.Leaves[0].Reader).GetNumericDocValues("dv1");
                 Assert.AreEqual(5, dv.Get(hits.ScoreDocs[i].Doc));
                 BinaryDocValues dv2 = ((AtomicReader)ireader.Leaves[0].Reader).GetBinaryDocValues("dv2");
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
index a19c6b4..a82465a 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility.cs
@@ -1,10 +1,10 @@
 using J2N;
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -434,7 +434,7 @@ namespace Lucene.Net.Index
             // true if this is a 4.2+ index
             bool is42Index = MultiFields.GetMergedFieldInfos(reader).FieldInfo("dvSortedSet") != null;
 
-            Debug.Assert(is40Index); // NOTE: currently we can only do this on trunk!
+            Debugging.Assert(() => is40Index); // NOTE: currently we can only do this on trunk!
 
             IBits liveDocs = MultiFields.GetLiveDocs(reader);
 
diff --git a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
index 8e84317..8fd5b72 100644
--- a/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/Index/TestBackwardsCompatibility3x.cs
@@ -1,9 +1,9 @@
 using J2N;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using Assert = Lucene.Net.TestFramework.Assert;
@@ -1039,7 +1039,7 @@ namespace Lucene.Net.Index
             Assert.AreEqual(1, td.TotalHits);
             AtomicReader wrapper = SlowCompositeReaderWrapper.Wrap(ir);
             DocsAndPositionsEnum de = wrapper.GetTermPositionsEnum(new Term("field3", "broken"));
-            Debug.Assert(de != null);
+            Debugging.Assert(() => de != null);
             Assert.AreEqual(0, de.NextDoc());
             Assert.AreEqual(0, de.NextPosition());
             ir.Dispose();
diff --git a/src/Lucene.Net.Tests/Index/TestCodecs.cs b/src/Lucene.Net.Tests/Index/TestCodecs.cs
index 332f635..2b7fbe3 100644
--- a/src/Lucene.Net.Tests/Index/TestCodecs.cs
+++ b/src/Lucene.Net.Tests/Index/TestCodecs.cs
@@ -1,12 +1,12 @@
 using J2N.Text;
 using J2N.Threading;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -446,7 +446,7 @@ namespace Lucene.Net.Index
                     for (int i = 0; i < NUM_TEST_THREADS - 1; i++)
                     {
                         threads[i].Join();
-                        Debug.Assert(!threads[i].failed);
+                        Debugging.Assert(() => !threads[i].failed);
                     }
 
                 }
@@ -759,14 +759,14 @@ namespace Lucene.Net.Index
                                         if (doc == DocIdSetIterator.NO_MORE_DOCS)
                                         {
                                             // skipped past last doc
-                                            Debug.Assert(upto2 == term2.docs.Length - 1);
+                                            Debugging.Assert(() => upto2 == term2.docs.Length - 1);
                                             ended = true;
                                             break;
                                         }
                                         else
                                         {
                                             // skipped to next doc
-                                            Debug.Assert(upto2 < term2.docs.Length - 1);
+                                            Debugging.Assert(() => upto2 < term2.docs.Length - 1);
                                             if (doc >= term2.docs[1 + upto2])
                                             {
                                                 upto2++;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
index b0c6bae..e195ed4 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
@@ -4,6 +4,7 @@ using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Codecs;
 using Lucene.Net.Codecs.SimpleText;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
@@ -12,11 +13,9 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Threading;
-using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
 using JCG = J2N.Collections.Generic;
 
@@ -2141,14 +2140,14 @@ namespace Lucene.Net.Index
             r = w.GetReader();
             long version2 = r.Version;
             r.Dispose();
-            Debug.Assert(version2 > version);
+            Debugging.Assert(() => version2 > version);
 
             w.DeleteDocuments(new Term("id", "0"));
             r = w.GetReader();
             w.Dispose();
             long version3 = r.Version;
             r.Dispose();
-            Debug.Assert(version3 > version2);
+            Debugging.Assert(() => version3 > version2);
             d.Dispose();
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
index 9faef06..a48d954 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
@@ -1,10 +1,10 @@
 using J2N.Threading;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -315,7 +315,7 @@ namespace Lucene.Net.Index
                         }
                         for (int i = 0; i < merge.Segments.Count; i++)
                         {
-                            Debug.Assert(merge.Segments[i].Info.DocCount < 20);
+                            Debugging.Assert(() => merge.Segments[i].Info.DocCount < 20);
                         }
                         writer.Merge(merge);
                     }
diff --git a/src/Lucene.Net.Tests/Index/TestIndexableField.cs b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
index 8d65685..b71cdf2 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexableField.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -317,7 +317,7 @@ namespace Lucene.Net.Index
                         }
                         else
                         {
-                            Debug.Assert(stringValue != null);
+                            Debugging.Assert(() => stringValue != null);
                             Assert.AreEqual(stringValue, f.GetStringValue());
                         }
                     }
@@ -424,7 +424,7 @@ namespace Lucene.Net.Index
                         return false;
                     }
 
-                    Debug.Assert(fieldUpto < outerInstance.fieldCount);
+                    Debugging.Assert(() => fieldUpto < outerInstance.fieldCount);
                     if (fieldUpto == 0)
                     {
                         fieldUpto = 1;
diff --git a/src/Lucene.Net.Tests/Index/TestLongPostings.cs b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
index ef3a68c..118fcaa 100644
--- a/src/Lucene.Net.Tests/Index/TestLongPostings.cs
+++ b/src/Lucene.Net.Tests/Index/TestLongPostings.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -462,9 +462,9 @@ namespace Lucene.Net.Index
                 else
                 {
                     docs = postings = TestUtil.Docs(Random, r, "field", new BytesRef(term), null, null, DocsFlags.FREQS);
-                    Debug.Assert(postings != null);
+                    Debugging.Assert(() => postings != null);
                 }
-                Debug.Assert(docs != null);
+                Debugging.Assert(() => docs != null);
 
                 int docID = -1;
                 while (docID < DocIdSetIterator.NO_MORE_DOCS)
diff --git a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
index 4c7e05d..e2a79c0 100644
--- a/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestNRTThreads.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading.Tasks;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -116,7 +116,7 @@ namespace Lucene.Net.Index
 
         protected override Directory GetDirectory(Directory @in)
         {
-            Debug.Assert(@in is MockDirectoryWrapper);
+            Debugging.Assert(() => @in is MockDirectoryWrapper);
             if (!useNonNrtReaders)
             {
                 ((MockDirectoryWrapper)@in).AssertNoDeleteOpenFile = true;
diff --git a/src/Lucene.Net.Tests/Index/TestPayloads.cs b/src/Lucene.Net.Tests/Index/TestPayloads.cs
index 40cae80..0f208af 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloads.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloads.cs
@@ -2,13 +2,13 @@ using J2N.Text;
 using J2N.Threading;
 using Lucene.Net.Analysis;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using Assert = Lucene.Net.TestFramework.Assert;
@@ -310,7 +310,7 @@ namespace Lucene.Net.Index
             // this test needs the random data to be valid unicode
             string s = TestUtil.RandomFixedByteLengthUnicodeString(Random, data.Length);
             var b = s.GetBytes(utf8);
-            Debug.Assert(b.Length == data.Length);
+            Debugging.Assert(() => b.Length == data.Length);
             System.Buffer.BlockCopy(b, 0, data, 0, b.Length);
         }
 
diff --git a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
index cd6a548..5b7e149 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloadsOnVectors.cs
@@ -1,9 +1,9 @@
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using Assert = Lucene.Net.TestFramework.Assert;
 
@@ -79,7 +79,7 @@ namespace Lucene.Net.Index
 
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(1, "field");
-            Debug.Assert(terms != null);
+            Debugging.Assert(() => terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
@@ -128,7 +128,7 @@ namespace Lucene.Net.Index
             writer.AddDocument(doc);
             DirectoryReader reader = writer.GetReader();
             Terms terms = reader.GetTermVector(0, "field");
-            Debug.Assert(terms != null);
+            Debugging.Assert(() => terms != null);
             TermsEnum termsEnum = terms.GetIterator(null);
             Assert.IsTrue(termsEnum.SeekExact(new BytesRef("withPayload")));
             DocsAndPositionsEnum de = termsEnum.DocsAndPositions(null, null);
diff --git a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
index c506b90..c621f33 100644
--- a/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/Index/TestPostingsOffsets.cs
@@ -1,11 +1,11 @@
 using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using Assert = Lucene.Net.TestFramework.Assert;
 
@@ -177,9 +177,9 @@ namespace Lucene.Net.Index
                     {
                         dp.NextPosition();
                         int start = dp.StartOffset;
-                        Debug.Assert(start >= 0);
+                        Debugging.Assert(() => start >= 0);
                         int end = dp.EndOffset;
-                        Debug.Assert(end >= 0 && end >= start);
+                        Debugging.Assert(() => end >= 0 && end >= start);
                         // check that the offsets correspond to the term in the src text
                         Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals(term, StringComparison.Ordinal));
                         if (withPayloads)
@@ -208,9 +208,9 @@ namespace Lucene.Net.Index
                     string storedNumbers = reader.Document(doc).Get("numbers");
                     dp.NextPosition();
                     int start = dp.StartOffset;
-                    Debug.Assert(start >= 0);
+                    Debugging.Assert(() => start >= 0);
                     int end = dp.EndOffset;
-                    Debug.Assert(end >= 0 && end >= start);
+                    Debugging.Assert(() => end >= 0 && end >= start);
                     // check that the offsets correspond to the term in the src text
                     Assert.IsTrue(storedNumbers.Substring(start, end - start).Equals("hundred", StringComparison.Ordinal));
                     if (withPayloads)
diff --git a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
index f0efbc9..aa7f52f 100644
--- a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs
@@ -2,6 +2,7 @@ using J2N.Collections.Generic.Extensions;
 using J2N.Text;
 using J2N.Threading;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Support;
@@ -9,7 +10,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.Threading;
 using Assert = Lucene.Net.TestFramework.Assert;
@@ -347,7 +347,7 @@ namespace Lucene.Net.Index
             }
             if (r1.NumDocs != r2.NumDocs)
             {
-                Debug.Assert(false, "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
+                Debugging.Assert(() => false, () => "r1.NumDocs=" + r1.NumDocs + " vs r2.NumDocs=" + r2.NumDocs);
             }
             bool hasDeletes = !(r1.MaxDoc == r2.MaxDoc && r1.NumDocs == r1.MaxDoc);
 
@@ -682,7 +682,7 @@ namespace Lucene.Net.Index
                 IIndexableField f2 = ff2[i];
                 if (f1.GetBinaryValue() != null)
                 {
-                    Debug.Assert(f2.GetBinaryValue() != null);
+                    Debugging.Assert(() => f2.GetBinaryValue() != null);
                 }
                 else
                 {
diff --git a/src/Lucene.Net.Tests/Index/TestStressNRT.cs b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
index 9acc423..ef4f795 100644
--- a/src/Lucene.Net.Tests/Index/TestStressNRT.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
@@ -1,12 +1,12 @@
 using J2N.Threading;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Threading;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -263,8 +263,8 @@ namespace Lucene.Net.Index
                                 {
                                     // install the new reader if it's newest (and check the current version since another reader may have already been installed)
                                     //System.out.println(Thread.currentThread().getName() + ": newVersion=" + newReader.getVersion());
-                                    Debug.Assert(newReader.RefCount > 0);
-                                    Debug.Assert(outerInstance.reader.RefCount > 0);
+                                    Debugging.Assert(() => newReader.RefCount > 0);
+                                    Debugging.Assert(() => outerInstance.reader.RefCount > 0);
                                     if (newReader.Version > outerInstance.reader.Version)
                                     {
                                         if (Verbose)
diff --git a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
index 912e6c7..def59ed 100644
--- a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Search;
@@ -5,10 +6,9 @@ using Lucene.Net.Util.Automaton;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using JCG = J2N.Collections.Generic;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
+using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Index
 {
@@ -829,7 +829,7 @@ namespace Lucene.Net.Index
                     }
                     else
                     {
-                        Debug.Assert(loc >= -validTerms.Length);
+                        Debugging.Assert(() => loc >= -validTerms.Length);
                         Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, result);
                     }
                 }
diff --git a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
index ea8710d..e8f5f73 100644
--- a/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
+++ b/src/Lucene.Net.Tests/Search/Spans/MultiSpansWrapper.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using System.Collections.Generic;
-using System.Diagnostics;
 using JCG = J2N.Collections.Generic;
 
 namespace Lucene.Net.Search.Spans
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search.Spans
             }
 
             int subIndex = ReaderUtil.SubIndex(target, leaves);
-            Debug.Assert(subIndex >= leafOrd);
+            Debugging.Assert(() => subIndex >= leafOrd);
             if (subIndex != leafOrd)
             {
                 AtomicReaderContext ctx = leaves[subIndex];
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
index 76a8e64..d203efb 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
@@ -1,9 +1,9 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Support;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 
 namespace Lucene.Net.Search
@@ -119,7 +119,7 @@ namespace Lucene.Net.Search
 
             public override bool Score(ICollector c, int maxDoc)
             {
-                Debug.Assert(doc == -1);
+                Debugging.Assert(() => doc == -1);
                 doc = 3000;
                 FakeScorer fs = new FakeScorer();
                 fs.doc = doc;
diff --git a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
index 55ca85c..a2aa38e 100644
--- a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
@@ -1,6 +1,6 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using NUnit.Framework;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 
 namespace Lucene.Net.Search
@@ -234,7 +234,7 @@ namespace Lucene.Net.Search
 
             Filter filter = new QueryWrapperFilter(AssertingQuery.Wrap(Random, new TermQuery(new Term("field", "a"))));
             IndexSearcher s = NewSearcher(r);
-            Debug.Assert(s is AssertingIndexSearcher);
+            Debugging.Assert(() => s is AssertingIndexSearcher);
             // this used to fail
             s.Search(new ConstantScoreQuery(filter), new TotalHitCountCollector());
 
diff --git a/src/Lucene.Net.Tests/Search/TestFieldCache.cs b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
index 39be70d..3358372 100644
--- a/src/Lucene.Net.Tests/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
@@ -1,11 +1,11 @@
 using J2N.Threading;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -34,42 +34,40 @@ namespace Lucene.Net.Search
      * limitations under the License.
      */
 
-    using MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
-    using BinaryDocValuesField = Lucene.Net.Documents.BinaryDocValuesField;
-    using Document = Lucene.Net.Documents.Document;
-    using Field = Lucene.Net.Documents.Field;
-    using Store = Lucene.Net.Documents.Field.Store;
-    using Int32Field = Lucene.Net.Documents.Int32Field;
-    using Int64Field = Lucene.Net.Documents.Int64Field;
-    using NumericDocValuesField = Lucene.Net.Documents.NumericDocValuesField;
-    using SortedDocValuesField = Lucene.Net.Documents.SortedDocValuesField;
-    using SortedSetDocValuesField = Lucene.Net.Documents.SortedSetDocValuesField;
-    using StoredField = Lucene.Net.Documents.StoredField;
     using AtomicReader = Lucene.Net.Index.AtomicReader;
     using BinaryDocValues = Lucene.Net.Index.BinaryDocValues;
+    using BinaryDocValuesField = Lucene.Net.Documents.BinaryDocValuesField;
+    using Bytes = Lucene.Net.Search.FieldCache.Bytes;
+    using BytesRef = Lucene.Net.Util.BytesRef;
+    using Directory = Lucene.Net.Store.Directory;
     using DirectoryReader = Lucene.Net.Index.DirectoryReader;
     using DocTermOrds = Lucene.Net.Index.DocTermOrds;
+    using Document = Lucene.Net.Documents.Document;
+    using Doubles = Lucene.Net.Search.FieldCache.Doubles;
+    using Field = Lucene.Net.Documents.Field;
+    using IBits = Lucene.Net.Util.IBits;
     using IndexReader = Lucene.Net.Index.IndexReader;
     using IndexWriter = Lucene.Net.Index.IndexWriter;
     using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig;
+    using Int16s = Lucene.Net.Search.FieldCache.Int16s;
+    using Int32Field = Lucene.Net.Documents.Int32Field;
+    using Int32s = Lucene.Net.Search.FieldCache.Int32s;
+    using Int64Field = Lucene.Net.Documents.Int64Field;
+    using Int64s = Lucene.Net.Search.FieldCache.Int64s;
+    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
+    using MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
+    using NumericDocValuesField = Lucene.Net.Documents.NumericDocValuesField;
     using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
+    using Singles = Lucene.Net.Search.FieldCache.Singles;
     using SlowCompositeReaderWrapper = Lucene.Net.Index.SlowCompositeReaderWrapper;
     using SortedDocValues = Lucene.Net.Index.SortedDocValues;
+    using SortedDocValuesField = Lucene.Net.Documents.SortedDocValuesField;
     using SortedSetDocValues = Lucene.Net.Index.SortedSetDocValues;
+    using SortedSetDocValuesField = Lucene.Net.Documents.SortedSetDocValuesField;
+    using StoredField = Lucene.Net.Documents.StoredField;
     using TermsEnum = Lucene.Net.Index.TermsEnum;
-    using Bytes = Lucene.Net.Search.FieldCache.Bytes;
-    using Doubles = Lucene.Net.Search.FieldCache.Doubles;
-    using Singles = Lucene.Net.Search.FieldCache.Singles;
-    using Int32s = Lucene.Net.Search.FieldCache.Int32s;
-    using Int64s = Lucene.Net.Search.FieldCache.Int64s;
-    using Int16s = Lucene.Net.Search.FieldCache.Int16s;
-    using Directory = Lucene.Net.Store.Directory;
-    using IBits = Lucene.Net.Util.IBits;
-    using BytesRef = Lucene.Net.Util.BytesRef;
-    using IOUtils = Lucene.Net.Util.IOUtils;
-    using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using TestUtil = Lucene.Net.Util.TestUtil;
-    
+
 
     [TestFixture]
     public class TestFieldCache : LuceneTestCase
@@ -374,7 +372,7 @@ namespace Lucene.Net.Search
                         break;
                     }
                     long ord = termOrds.NextOrd();
-                    Debug.Assert(ord != SortedSetDocValues.NO_MORE_ORDS);
+                    Debugging.Assert(() => ord != SortedSetDocValues.NO_MORE_ORDS);
                     BytesRef scratch = new BytesRef();
                     termOrds.LookupOrd(ord, scratch);
                     Assert.AreEqual(v, scratch);
diff --git a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
index 443d366..6157c9a 100644
--- a/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
+++ b/src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs
@@ -1,14 +1,14 @@
-using System.Linq;
+using J2N.Collections.Generic.Extensions;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Support;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Linq;
 using Assert = Lucene.Net.TestFramework.Assert;
 using JCG = J2N.Collections.Generic;
-using J2N.Collections.Generic.Extensions;
 
 namespace Lucene.Net.Search
 {
@@ -365,14 +365,14 @@ namespace Lucene.Net.Search
                 this.sims = new SimScorer[(int)dv.ValueCount];
                 foreach (BooleanClause clause in bq.GetClauses())
                 {
-                    Debug.Assert(!clause.IsProhibited);
-                    Debug.Assert(!clause.IsRequired);
+                    Debugging.Assert(() => !clause.IsProhibited);
+                    Debugging.Assert(() => !clause.IsRequired);
                     Term term = ((TermQuery)clause.Query).Term;
                     long ord = dv.LookupTerm(term.Bytes);
                     if (ord >= 0)
                     {
                         bool success = ords.Add(ord);
-                        Debug.Assert(success); // no dups
+                        Debugging.Assert(() => success); // no dups
                         TermContext context = TermContext.Build(reader.Context, term);
                         SimWeight w = weight.Similarity.ComputeWeight(1f, searcher.CollectionStatistics("field"), searcher.TermStatistics(term, context));
                         var dummy = w.GetValueForNormalization(); // ignored
@@ -384,7 +384,7 @@ namespace Lucene.Net.Search
 
             public override float GetScore()
             {
-                Debug.Assert(score != 0, currentMatched.ToString());
+                Debugging.Assert(() => score != 0, currentMatched.ToString);
                 return (float)score * ((BooleanWeight)m_weight).Coord(currentMatched, ((BooleanWeight)m_weight).MaxCoord);
             }
 
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
 
             public override int NextDoc()
             {
-                Debug.Assert(currentDoc != NO_MORE_DOCS);
+                Debugging.Assert(() => currentDoc != NO_MORE_DOCS);
                 for (currentDoc = currentDoc + 1; currentDoc < maxDoc; currentDoc++)
                 {
                     currentMatched = 0;
diff --git a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
index 762cc4e..f6c0ac7 100644
--- a/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
+++ b/src/Lucene.Net.Tests/Search/TestMultiThreadTermVectors.cs
@@ -1,9 +1,9 @@
 using J2N.Threading;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Text;
 using System.Threading;
@@ -223,7 +223,7 @@ namespace Lucene.Net.Search
             foreach (string field in vectors)
             {
                 Terms terms = vectors.GetTerms(field);
-                Debug.Assert(terms != null);
+                Debugging.Assert(() => terms != null);
                 VerifyVector(terms.GetIterator(null), num);
             }
         }
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
index 16860f2..a7dc07e 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery32.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -32,7 +32,6 @@ namespace Lucene.Net.Search
     using Document = Documents.Document;
     using Field = Field;
     using FieldType = FieldType;
-    using SingleField = SingleField;
     using IndexReader = Lucene.Net.Index.IndexReader;
     using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
@@ -40,6 +39,7 @@ namespace Lucene.Net.Search
     using MultiFields = Lucene.Net.Index.MultiFields;
     using NumericUtils = Lucene.Net.Util.NumericUtils;
     using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
+    using SingleField = SingleField;
     using SlowCompositeReaderWrapper = Lucene.Net.Index.SlowCompositeReaderWrapper;
     using Terms = Lucene.Net.Index.Terms;
     using TermsEnum = Lucene.Net.Index.TermsEnum;
@@ -474,13 +474,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             int lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            Debug.Assert(lower < upper);
+            Debugging.Assert(() => lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2 * lower;
-            Debug.Assert(lower < upper);
+            Debugging.Assert(() => lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
index 0da43cd..4e0ad53 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index.Extensions;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -501,13 +501,13 @@ namespace Lucene.Net.Search
             int count = 3000;
             long lower = (distance * 3 / 2) + startOffset, upper = lower + count * distance + (distance / 3);
             // test empty enum
-            Debug.Assert(lower < upper);
+            Debugging.Assert(() => lower < upper);
             Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, upper, lower, true, true)));
             // test empty enum outside of bounds
             lower = distance * noDocs + startOffset;
             upper = 2L * lower;
-            Debug.Assert(lower < upper);
+            Debugging.Assert(() => lower < upper);
             Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
         }
 
diff --git a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
index 243145e..6ebd621 100644
--- a/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
+++ b/src/Lucene.Net.Tests/Search/TestTimeLimitingCollector.cs
@@ -1,6 +1,7 @@
 using J2N.Text;
 using J2N.Threading;
 using Lucene.Net.Analysis;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -8,7 +9,6 @@ using Lucene.Net.Store;
 using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Text.RegularExpressions;
 using Console = Lucene.Net.Util.SystemConsole;
 
@@ -418,7 +418,7 @@ namespace Lucene.Net.Search
 //#endif
                 }
 
-                Debug.Assert(docId >= 0, " base=" + docBase + " doc=" + doc);
+                Debugging.Assert(() => docId >= 0, () => " base=" + docBase + " doc=" + doc);
                 bits.Set(docId);
                 lastDocCollected = docId;
             }
diff --git a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
index 0f7dffb..b18aaa8 100644
--- a/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
+++ b/src/Lucene.Net.Tests/Util/Automaton/TestUTF32ToUTF8.cs
@@ -1,8 +1,8 @@
 using J2N;
 using J2N.Text;
+using Lucene.Net.Diagnostics;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using System.Text;
 using Assert = Lucene.Net.TestFramework.Assert;
 using Console = Lucene.Net.Util.SystemConsole;
@@ -76,7 +76,7 @@ namespace Lucene.Net.Util.Automaton
                 nonSurrogateCount = endCode - startCode + 1 - (UnicodeUtil.UNI_SUR_LOW_END - UnicodeUtil.UNI_SUR_HIGH_START + 1);
             }
 
-            Debug.Assert(nonSurrogateCount > 0);
+            Debugging.Assert(() => nonSurrogateCount > 0);
 
             for (int iter = 0; iter < iters; iter++)
             {
@@ -95,8 +95,8 @@ namespace Lucene.Net.Util.Automaton
                     }
                 }
 
-                Debug.Assert(code >= startCode && code <= endCode, "code=" + code + " start=" + startCode + " end=" + endCode);
-                Debug.Assert(!IsSurrogate(code));
+                Debugging.Assert(() => code >= startCode && code <= endCode, () => "code=" + code + " start=" + startCode + " end=" + endCode);
+                Debugging.Assert(() => !IsSurrogate(code));
 
                 Assert.IsTrue(Matches(a, code), "DFA for range " + startCode + "-" + endCode + " failed to match code=" + code);
             }
diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
index 1912f1f..df67774 100644
--- a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
+++ b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
@@ -1,12 +1,12 @@
 using J2N.Collections.Generic.Extensions;
 using J2N.Threading.Atomic;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Index.Extensions;
 using Lucene.Net.Support;
 using Lucene.Net.Util.Automaton;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -571,7 +571,7 @@ namespace Lucene.Net.Util.Fst
                     long tMid = Environment.TickCount;
                     Console.WriteLine(((tMid - tStart) / 1000.0) + " sec to add all terms");
 
-                    Debug.Assert(builder.TermCount == ord);
+                    Debugging.Assert(() => builder.TermCount == ord);
                     FST<T> fst = builder.Finish();
                     long tEnd = Environment.TickCount;
                     Console.WriteLine(((tEnd - tMid) / 1000.0) + " sec to finish/pack");
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
index 934890a..e7cb03c 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoDocIdSet.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using Lucene.Net.Diagnostics;
 using BitSet = J2N.Collections.BitSet;
 
 namespace Lucene.Net.Util.Packed
@@ -52,7 +52,7 @@ namespace Lucene.Net.Util.Packed
                 {
                     doc = NO_MORE_DOCS;
                 }
-                Debug.Assert(doc < numBits);
+                Debugging.Assert(() => doc < numBits);
                 return doc;
             }
 
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
index e207049..35b2633 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
@@ -1,7 +1,7 @@
 using Lucene.Net.Attributes;
+using Lucene.Net.Diagnostics;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 
 namespace Lucene.Net.Util.Packed
@@ -91,7 +91,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeAdvanceToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test advancing to multiples of m
-            Debug.Assert(m > 0);
+            Debugging.Assert(() => m > 0);
             long previousValue = -1L;
             long index = 0;
             long mm = m;
@@ -120,7 +120,7 @@ namespace Lucene.Net.Util.Packed
         private static void TstDecodeBackToMultiples(long[] values, EliasFanoDecoder efd, long m)
         {
             // test backing to multiples of m
-            Debug.Assert(m > 0);
+            Debugging.Assert(() => m > 0);
             efd.ToAfterSequence();
             int index = values.Length - 1;
             if (index < 0)
@@ -135,7 +135,7 @@ namespace Lucene.Net.Util.Packed
             while (index >= 0)
             {
                 expValue = values[index];
-                Debug.Assert(mm < previousValue);
+                Debugging.Assert(() => mm < previousValue);
                 if (expValue <= mm)
                 {
                     long backValue_ = efd.BackToValue(mm);
diff --git a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
index e9da5ad..63a75b9 100644
--- a/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
+++ b/src/Lucene.Net.Tests/Util/Test2BPagedBytes.cs
@@ -1,7 +1,7 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Store;
 using NUnit.Framework;
 using System;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 
 namespace Lucene.Net.Util
@@ -57,7 +57,7 @@ namespace Lucene.Net.Util
                 r2.NextBytes(bytes);
                 dataOutput.WriteBytes(bytes, bytes.Length);
                 long fp = dataOutput.GetFilePointer();
-                Debug.Assert(fp == lastFP + numBytes);
+                Debugging.Assert(() => fp == lastFP + numBytes);
                 lastFP = fp;
                 netBytes += numBytes;
             }
diff --git a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
index e6fa9d8..f31d3ce 100644
--- a/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestWAH8DocIdSet.cs
@@ -1,8 +1,8 @@
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Search;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using Assert = Lucene.Net.TestFramework.Assert;
 using BitSet = J2N.Collections.BitSet;
 
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
         /// Create a random set which has <paramref name="numBitsSet"/> of its <paramref name="numBits"/> bits set. </summary>
         protected static OpenBitSet RandomOpenSet(int numBits, int numBitsSet)
         {
-            Debug.Assert(numBitsSet <= numBits);
+            Debugging.Assert(() => numBitsSet <= numBits);
             OpenBitSet set = new OpenBitSet(numBits);
             Random random = Random;
             if (numBitsSet == numBits)
diff --git a/src/dotnet/Lucene.Net.Tests.ICU/Search/PostingsHighlight/TestICUPostingsHighlighter.cs b/src/dotnet/Lucene.Net.Tests.ICU/Search/PostingsHighlight/TestICUPostingsHighlighter.cs
index 4a1212c..29a1360 100644
--- a/src/dotnet/Lucene.Net.Tests.ICU/Search/PostingsHighlight/TestICUPostingsHighlighter.cs
+++ b/src/dotnet/Lucene.Net.Tests.ICU/Search/PostingsHighlight/TestICUPostingsHighlighter.cs
@@ -2,6 +2,7 @@
 using ICU4N.Text;
 using Lucene.Net.Analysis;
 using Lucene.Net.Attributes;
+using Lucene.Net.Diagnostics;
 using Lucene.Net.Documents;
 using Lucene.Net.Index;
 using Lucene.Net.Index.Extensions;
@@ -10,7 +11,6 @@ using Lucene.Net.Util;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Text;
@@ -774,8 +774,8 @@ namespace Lucene.Net.Search.PostingsHighlight
 
             protected override IList<string[]> LoadFieldValues(IndexSearcher searcher, string[] fields, int[] docids, int maxLength)
             {
-                Debug.Assert( fields.Length == 1);
-                Debug.Assert( docids.Length == 1);
+                Debugging.Assert(() => fields.Length == 1);
+                Debugging.Assert(() => docids.Length == 1);
                 String[][] contents = RectangularArrays.ReturnRectangularArray<string>(1, 1); //= new String[1][1];
                 contents[0][0] = text;
                 return contents;
@@ -1178,7 +1178,7 @@ namespace Lucene.Net.Search.PostingsHighlight
         {
             protected override char GetMultiValuedSeparator(string field)
             {
-                Debug.Assert( field.Equals("body", StringComparison.Ordinal));
+                Debugging.Assert(() => field.Equals("body", StringComparison.Ordinal));
                 return '\u2029';
             }
         }