lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [1/4] lucenenet git commit: Lucene.Net.Tests: Removed Timeout attribute from tests where it was only used to allow the test to run longer than the 20 second timeout that used to be project-wide
Date Fri, 22 Sep 2017 10:06:50 GMT
Repository: lucenenet
Updated Branches:
  refs/heads/master 2368a020d -> 485403805


Lucene.Net.Tests: Removed Timeout attribute from tests where it was only used to allow the test to run longer than the 20 second timeout that used to be project-wide


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/3428d818
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/3428d818
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/3428d818

Branch: refs/heads/master
Commit: 3428d818d175a787344166b03796e7433470b54c
Parents: 2368a02
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Fri Sep 22 16:00:46 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Fri Sep 22 16:03:00 2017 +0700

----------------------------------------------------------------------
 .../Analysis/TestLookaheadTokenFilter.cs          | 12 ++----------
 src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs |  6 +-----
 .../TestCompressingStoredFieldsFormat.cs          |  6 +-----
 .../TestCompressingTermVectorsFormat.cs           |  6 +-----
 .../Lucene3x/TestLucene3xStoredFieldsFormat.cs    | 12 ++----------
 .../Lucene3x/TestLucene3xTermVectorsFormat.cs     |  6 +-----
 .../Codecs/Lucene3x/TestSurrogates.cs             |  6 +-----
 .../Lucene40/TestLucene40StoredFieldsFormat.cs    | 18 +++---------------
 .../Lucene40/TestLucene40TermVectorsFormat.cs     |  6 +-----
 .../Codecs/Lucene41/TestBlockPostingsFormat3.cs   |  6 +-----
 .../Lucene41/TestLucene41StoredFieldsFormat.cs    | 18 +++---------------
 .../PerField/TestPerFieldDocValuesFormat.cs       |  6 +-----
 .../Index/Test2BBinaryDocValues.cs                | 12 ++----------
 .../Index/Test2BNumericDocValues.cs               |  6 +-----
 src/Lucene.Net.Tests/Index/Test2BPositions.cs     |  6 +-----
 src/Lucene.Net.Tests/Index/Test2BPostings.cs      |  6 +-----
 src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs |  6 +-----
 .../Index/Test2BSortedDocValues.cs                | 12 ++----------
 src/Lucene.Net.Tests/Index/Test2BTerms.cs         |  6 +-----
 src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs |  6 +-----
 src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs    |  6 +-----
 .../Index/TestBinaryDocValuesUpdates.cs           |  6 +-----
 src/Lucene.Net.Tests/Index/TestByteSlices.cs      |  6 +-----
 .../Index/TestConcurrentMergeScheduler.cs         | 18 +++---------------
 src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs  |  6 +-----
 src/Lucene.Net.Tests/Index/TestDirectoryReader.cs |  6 +-----
 src/Lucene.Net.Tests/Index/TestDocTermOrds.cs     |  6 +-----
 src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs   |  6 +-----
 .../Index/TestIndexWriterDelete.cs                |  6 +-----
 .../Index/TestIndexWriterMerging.cs               |  6 +-----
 .../Index/TestIndexWriterReader.cs                | 18 +++---------------
 .../Index/TestMixedDocValuesUpdates.cs            |  6 +-----
 .../Index/TestNRTReaderWithThreads.cs             |  6 +-----
 .../Index/TestNumericDocValuesUpdates.cs          |  6 +-----
 .../Index/TestStoredFieldsFormat.cs               |  6 +-----
 src/Lucene.Net.Tests/Index/TestTermdocPerf.cs     |  6 +-----
 src/Lucene.Net.Tests/Index/TestTermsEnum.cs       |  6 +-----
 src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs |  6 +-----
 .../Search/TestControlledRealTimeReopenThread.cs  | 12 ++----------
 .../Search/TestFieldCacheRewriteMethod.cs         |  6 +-----
 .../Search/TestNumericRangeQuery64.cs             |  6 +-----
 src/Lucene.Net.Tests/Search/TestScorerPerf.cs     |  3 ++-
 src/Lucene.Net.Tests/Search/TestSearchAfter.cs    |  6 +-----
 .../Search/TestSearcherManager.cs                 |  6 +-----
 src/Lucene.Net.Tests/Store/TestCopyBytes.cs       |  6 +-----
 src/Lucene.Net.Tests/Store/TestDirectory.cs       | 12 ++----------
 src/Lucene.Net.Tests/Store/TestHugeRamFile.cs     |  6 +-----
 src/Lucene.Net.Tests/Store/TestLockFactory.cs     |  6 +-----
 src/Lucene.Net.Tests/Store/TestMultiMMap.cs       | 12 ++----------
 src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs |  3 ++-
 src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs   |  6 +-----
 src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs         |  6 +-----
 .../Util/Packed/TestEliasFanoSequence.cs          | 12 ++----------
 .../Util/Packed/TestPackedInts.cs                 | 12 ++----------
 .../Util/StressRamUsageEstimator.cs               |  6 +-----
 src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs      |  6 +-----
 src/Lucene.Net.Tests/Util/TestFixedBitSet.cs      | 12 ++----------
 src/Lucene.Net.Tests/Util/TestNumericUtils.cs     |  6 +-----
 src/Lucene.Net.Tests/Util/TestOfflineSorter.cs    | 18 +++---------------
 src/Lucene.Net.Tests/Util/TestOpenBitSet.cs       |  6 +-----
 src/Lucene.Net.Tests/Util/TestPagedBytes.cs       | 18 +++---------------
 src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs  |  6 +-----
 62 files changed, 86 insertions(+), 412 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Analysis/TestLookaheadTokenFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Analysis/TestLookaheadTokenFilter.cs b/src/Lucene.Net.Tests/Analysis/TestLookaheadTokenFilter.cs
index ee733bd..e5fda11 100644
--- a/src/Lucene.Net.Tests/Analysis/TestLookaheadTokenFilter.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestLookaheadTokenFilter.cs
@@ -26,11 +26,7 @@ namespace Lucene.Net.Analysis
     [TestFixture]
     public class TestLookaheadTokenFilter : BaseTokenStreamTestCase
     {
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestRandomStrings()
         {
             Analyzer a = new AnalyzerAnonymousInnerClassHelper(this);
@@ -73,11 +69,7 @@ namespace Lucene.Net.Analysis
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestNeverCallingPeek()
         {
             Analyzer a = new NCPAnalyzerAnonymousInnerClassHelper(this);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs b/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
index 5f8ad17..4b4eb35 100644
--- a/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
@@ -229,11 +229,7 @@ namespace Lucene.Net.Analysis
 
         /// <summary>
         /// blast some random strings through differently configured tokenizers </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestRandomRegexps()
         {
             int iters = AtLeast(30);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
index 3adfebf..59dabbf 100644
--- a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
@@ -167,11 +167,7 @@ namespace Lucene.Net.Codecs.Compressing
             base.TestWriteReadMerge();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestBigDocuments()
         {
             base.TestBigDocuments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingTermVectorsFormat.cs b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
index 1ce3276..4e87ced 100644
--- a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingTermVectorsFormat.cs
@@ -128,11 +128,7 @@ namespace Lucene.Net.Codecs.Compressing
             base.TestRandom();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(30000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public override void TestMerge()
         {
             base.TestMerge();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
index 3682335..04817e7 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xStoredFieldsFormat.cs
@@ -101,21 +101,13 @@ namespace Lucene.Net.Codecs.Lucene3x
             base.TestEmptyDocs();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(40000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public override void TestConcurrentReads()
         {
             base.TestConcurrentReads();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestBigDocuments()
         {
             base.TestBigDocuments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
index 7b7ed3a..83a165a 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestLucene3xTermVectorsFormat.cs
@@ -72,11 +72,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             base.TestLotsOfFields();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         // different options for the same field
         public override void TestMixedOptions()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
index ea79a18..1272ea7 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene3x/TestSurrogates.cs
@@ -340,11 +340,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSurrogatesOrder()
         {
             Directory dir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
index 3ae63f7..084dfa2 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40StoredFieldsFormat.cs
@@ -83,21 +83,13 @@ namespace Lucene.Net.Codecs.Lucene40
             base.TestReadSkip();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestEmptyDocs()
         {
             base.TestEmptyDocs();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestConcurrentReads()
         {
             base.TestConcurrentReads();
@@ -109,11 +101,7 @@ namespace Lucene.Net.Codecs.Lucene40
             base.TestWriteReadMerge();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(80000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestBigDocuments()
         {
             base.TestBigDocuments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
index 4370228..2534902 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene40/TestLucene40TermVectorsFormat.cs
@@ -64,11 +64,7 @@ namespace Lucene.Net.Codecs.Lucene40
             base.TestLotsOfFields();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         // different options for the same field
         public override void TestMixedOptions()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
index 4705320..4f2e5df 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene41/TestBlockPostingsFormat3.cs
@@ -74,11 +74,7 @@ namespace Lucene.Net.Codecs.Lucene41
         internal static readonly int MAXDOC = Lucene41PostingsFormat.BLOCK_SIZE * 20;
 
         // creates 8 fields with different options and does "duels" of fields against each other
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(50000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test()
         {
             Directory dir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/Lucene41/TestLucene41StoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/Lucene41/TestLucene41StoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Lucene41/TestLucene41StoredFieldsFormat.cs
index 3f1b59d..19dda6d 100644
--- a/src/Lucene.Net.Tests/Codecs/Lucene41/TestLucene41StoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Lucene41/TestLucene41StoredFieldsFormat.cs
@@ -83,21 +83,13 @@ namespace Lucene.Net.Codecs.Lucene41
             base.TestReadSkip();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestEmptyDocs()
         {
             base.TestEmptyDocs();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestConcurrentReads()
         {
             base.TestConcurrentReads();
@@ -109,11 +101,7 @@ namespace Lucene.Net.Codecs.Lucene41
             base.TestWriteReadMerge();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestBigDocuments()
         {
             base.TestBigDocuments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
index 2297259..b98564f 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
@@ -542,11 +542,7 @@ namespace Lucene.Net.Codecs.PerField
             base.TestSortedSetFixedLengthVsUninvertedField();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestSortedSetVariableLengthVsUninvertedField()
         {
             base.TestSortedSetVariableLengthVsUninvertedField();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BBinaryDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BBinaryDocValues.cs b/src/Lucene.Net.Tests/Index/Test2BBinaryDocValues.cs
index 1c8cd07..4e2d570 100644
--- a/src/Lucene.Net.Tests/Index/Test2BBinaryDocValues.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BBinaryDocValues.cs
@@ -40,11 +40,7 @@ namespace Lucene.Net.Index
     public class Test2BBinaryDocValues : LuceneTestCase
     {
         // indexes Integer.MAX_VALUE docs with a fixed binary field
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestFixedBinary([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BFixedBinary"));
@@ -110,11 +106,7 @@ namespace Lucene.Net.Index
         }
 
         // indexes Integer.MAX_VALUE docs with a variable binary field
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestVariableBinary([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BVariableBinary"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BNumericDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BNumericDocValues.cs b/src/Lucene.Net.Tests/Index/Test2BNumericDocValues.cs
index 3bb389c..d9962e3 100644
--- a/src/Lucene.Net.Tests/Index/Test2BNumericDocValues.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BNumericDocValues.cs
@@ -38,11 +38,7 @@ namespace Lucene.Net.Index
     public class Test2BNumericDocValues : LuceneTestCase
     {
         // indexes Integer.MAX_VALUE docs with an increasing dv field
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestNumerics([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BNumerics"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BPositions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BPositions.cs b/src/Lucene.Net.Tests/Index/Test2BPositions.cs
index 4d980a3..73d9244 100644
--- a/src/Lucene.Net.Tests/Index/Test2BPositions.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BPositions.cs
@@ -52,11 +52,7 @@ namespace Lucene.Net.Index
     // uses lots of space and takes a few minutes
     {
         [Ignore("Very slow. Enable manually by removing Ignore.")]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BPositions"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BPostings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BPostings.cs b/src/Lucene.Net.Tests/Index/Test2BPostings.cs
index 7e30f71..05716d7 100644
--- a/src/Lucene.Net.Tests/Index/Test2BPostings.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BPostings.cs
@@ -46,11 +46,7 @@ namespace Lucene.Net.Index
     public class Test2BPostings : LuceneTestCase
     {
         [Ignore("Very slow. Enable manually by removing Ignore.")]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BPostings"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs b/src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs
index 16fc13d..a111b3d 100644
--- a/src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BPostingsBytes.cs
@@ -53,11 +53,7 @@ namespace Lucene.Net.Index
     // with some codecs needs more heap space as well.
     {
         [Ignore("Very slow. Enable manually by removing Ignore.")]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BPostingsBytes1"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BSortedDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BSortedDocValues.cs b/src/Lucene.Net.Tests/Index/Test2BSortedDocValues.cs
index a6534f1..855a54b 100644
--- a/src/Lucene.Net.Tests/Index/Test2BSortedDocValues.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BSortedDocValues.cs
@@ -38,11 +38,7 @@ namespace Lucene.Net.Index
     public class Test2BSortedDocValues : LuceneTestCase
     {
         // indexes Integer.MAX_VALUE docs with a fixed binary field
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestFixedSorted([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BFixedSorted"));
@@ -103,12 +99,8 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
         // indexes Integer.MAX_VALUE docs with a fixed binary field
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test2BOrds([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("2BOrds"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test2BTerms.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test2BTerms.cs b/src/Lucene.Net.Tests/Index/Test2BTerms.cs
index 2636752..5f9b77f 100644
--- a/src/Lucene.Net.Tests/Index/Test2BTerms.cs
+++ b/src/Lucene.Net.Tests/Index/Test2BTerms.cs
@@ -169,11 +169,7 @@ namespace Lucene.Net.Index
         }
 
         [Ignore("Very slow. Enable manually by removing Ignore.")]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test2BTerms_Mem([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             if ("Lucene3x".Equals(Codec.Default.Name))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs b/src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs
index ce6832b..c8081ab 100644
--- a/src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs
+++ b/src/Lucene.Net.Tests/Index/Test4GBStoredFields.cs
@@ -43,11 +43,7 @@ namespace Lucene.Net.Index
     public class Test4GBStoredFields : LuceneTestCase
     {
         [Ignore("//LUCENENET NOTE: This was marked Nightly in Java")]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void Test([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             MockDirectoryWrapper dir = new MockDirectoryWrapper(Random(), new MMapDirectory(CreateTempDir("4GBStoredFields")));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs b/src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs
index b7f5a7f..a1759f3 100644
--- a/src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs
+++ b/src/Lucene.Net.Tests/Index/TestAtomicUpdate.cs
@@ -195,11 +195,7 @@ namespace Lucene.Net.Index
           FSDirectory.
         */
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestAtomicUpdates()
         {
             Directory directory;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
index d2a912b..66ccb80 100644
--- a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
@@ -1622,11 +1622,7 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestTonsOfUpdates()
         {
             // LUCENE-5248: make sure that when there are many updates, we don't use too much RAM

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestByteSlices.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestByteSlices.cs b/src/Lucene.Net.Tests/Index/TestByteSlices.cs
index a0d5337..71d170f 100644
--- a/src/Lucene.Net.Tests/Index/TestByteSlices.cs
+++ b/src/Lucene.Net.Tests/Index/TestByteSlices.cs
@@ -30,11 +30,7 @@ namespace Lucene.Net.Index
     [TestFixture]
     public class TestByteSlices : LuceneTestCase
     {
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestBasic()
         {
             // LUCENENET specific: NUnit will crash with an OOM if we do the full test

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs b/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
index b263660..7275e62 100644
--- a/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
+++ b/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
@@ -201,11 +201,7 @@ namespace Lucene.Net.Index
             directory.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestNoExtraFiles()
         {
             Directory directory = NewDirectory();
@@ -237,11 +233,7 @@ namespace Lucene.Net.Index
             directory.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestNoWaitClose()
         {
             Directory directory = NewDirectory();
@@ -406,11 +398,7 @@ namespace Lucene.Net.Index
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestTotalBytesSize()
         {
             Directory d = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs b/src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs
index 9f7dc79..306dcaf 100644
--- a/src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs
+++ b/src/Lucene.Net.Tests/Index/TestDeletionPolicy.cs
@@ -668,11 +668,7 @@ namespace Lucene.Net.Index
          * around, through creates.
          */
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestKeepLastNDeletionPolicyWithCreates()
         {
             const int N = 10;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs b/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
index 3df3da7..02df86e 100644
--- a/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
+++ b/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
@@ -311,11 +311,7 @@ namespace Lucene.Net.Index
             d.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(40000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public virtual void TestTermVectors()
         {
             Directory d = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestDocTermOrds.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestDocTermOrds.cs b/src/Lucene.Net.Tests/Index/TestDocTermOrds.cs
index 18d24d7..7b4129a 100644
--- a/src/Lucene.Net.Tests/Index/TestDocTermOrds.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocTermOrds.cs
@@ -196,11 +196,7 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestRandomWithPrefix()
         {
             Directory dir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs b/src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs
index 06023cd..55c0b11 100644
--- a/src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs
+++ b/src/Lucene.Net.Tests/Index/TestDuelingCodecs.cs
@@ -171,11 +171,7 @@ namespace Lucene.Net.Index
         /// <summary>
         /// checks the two indexes are equivalent
         /// </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestEquals()
         {
             AssertReaderEquals(Info, LeftReader, RightReader);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
index 032f8e8..2a93606 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
@@ -1306,11 +1306,7 @@ namespace Lucene.Net.Index
 
         // Make sure buffered (pushed) deletes don't use up so
         // much RAM that it forces long tail of tiny segments:
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestApplyDeletesOnFlush()
         {
             Directory dir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
index 4a0abc0..884aa19 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
@@ -350,11 +350,7 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(80000)]
-#endif
-        [Test, LongRunningTest, HasTimeout] // LUCENENET TODO: Can this test be optimized to run faster on .NET Core 1.0?
+        [Test, LongRunningTest] // LUCENENET TODO: Can this test be optimized to run faster on .NET Core 1.0?
         public virtual void TestNoWaitClose()
         {
             Directory directory = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
index 4e8790d..f4c1205 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
@@ -423,11 +423,7 @@ namespace Lucene.Net.Index
             dir1.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestAddIndexesAndDoDeletesThreads()
         {
             const int numIter = 2;
@@ -746,11 +742,7 @@ namespace Lucene.Net.Index
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestMergeWarmer([ValueSource(typeof(ConcurrentMergeSchedulerFactories), "Values")]Func<IConcurrentMergeScheduler> newScheduler)
         {
             Directory dir1 = GetAssertNoDeletesDirectory(NewDirectory());
@@ -1408,11 +1400,7 @@ namespace Lucene.Net.Index
         /// Make sure if all we do is open NRT reader against
         ///  writer, we don't see merge starvation.
         /// </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestTooManySegments()
         {
             Directory dir = GetAssertNoDeletesDirectory(NewDirectory());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
index ec7510b..8b29f9c 100644
--- a/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
@@ -491,11 +491,7 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(180000)]
-#endif
-        [Test, LongRunningTest, HasTimeout] // LUCENENET TODO: Can this test be optimized to run faster on .NET Core 1.0?
+        [Test, LongRunningTest] // LUCENENET TODO: Can this test be optimized to run faster on .NET Core 1.0?
         public virtual void TestTonsOfUpdates()
         {
             // LUCENE-5248: make sure that when there are many updates, we don't use too much RAM

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestNRTReaderWithThreads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestNRTReaderWithThreads.cs b/src/Lucene.Net.Tests/Index/TestNRTReaderWithThreads.cs
index 178a97c..033da39 100644
--- a/src/Lucene.Net.Tests/Index/TestNRTReaderWithThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestNRTReaderWithThreads.cs
@@ -37,11 +37,7 @@ namespace Lucene.Net.Index
     {
         internal AtomicInt32 Seq = new AtomicInt32(1);
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestIndexing()
         {
             Directory mainDir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
index 455671c..37f3f86 100644
--- a/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
@@ -1536,11 +1536,7 @@ namespace Lucene.Net.Index
             dir.Dispose();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(180000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestTonsOfUpdates()
         {
             // LUCENE-5248: make sure that when there are many updates, we don't use too much RAM

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestStoredFieldsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestStoredFieldsFormat.cs b/src/Lucene.Net.Tests/Index/TestStoredFieldsFormat.cs
index 9c551f3..367a548 100644
--- a/src/Lucene.Net.Tests/Index/TestStoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Index/TestStoredFieldsFormat.cs
@@ -107,11 +107,7 @@ namespace Lucene.Net.Index
             base.TestConcurrentReads();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestBigDocuments()
         {
             base.TestBigDocuments();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs b/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
index b25ee38..8c9dcee 100644
--- a/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
@@ -165,11 +165,7 @@ namespace Lucene.Net.Index
             return ret;
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestTermDocPerf()
         {
             // performance test for 10% of documents containing a term

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
index f3574c4..fff1c90 100644
--- a/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermsEnum.cs
@@ -230,11 +230,7 @@ namespace Lucene.Net.Index
         }
 
         // Tests Terms.intersect
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestIntersectRandom()
         {
             Directory dir = NewDirectory();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs b/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
index 1da4668..7d99533 100644
--- a/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
@@ -224,11 +224,7 @@ namespace Lucene.Net.Search
             Assert.AreEqual(0, AutomatonQueryNrHits(aq));
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(40000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestHashCodeWithThreads()
         {
             AutomatonQuery[] queries = new AutomatonQuery[1000];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs b/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
index 0917da3..f7d2d33 100644
--- a/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
+++ b/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
@@ -381,11 +381,7 @@ namespace Lucene.Net.Search
         /*
          * LUCENE-3528 - NRTManager hangs in certain situations 
          */
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestThreadStarvationNoDeleteNRTReader()
         {
             IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
@@ -637,12 +633,8 @@ namespace Lucene.Net.Search
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(40000)]
-#endif
         // LUCENE-5461
-        [Test, HasTimeout]
+        [Test]
         public virtual void TestCRTReopen()
         {
             //test behaving badly

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestFieldCacheRewriteMethod.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestFieldCacheRewriteMethod.cs b/src/Lucene.Net.Tests/Search/TestFieldCacheRewriteMethod.cs
index 671a5b7..484686b 100644
--- a/src/Lucene.Net.Tests/Search/TestFieldCacheRewriteMethod.cs
+++ b/src/Lucene.Net.Tests/Search/TestFieldCacheRewriteMethod.cs
@@ -73,11 +73,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// test a bunch of random regular expressions </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestRegexps()
         {
             base.TestRegexps();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
index 28e3ec0..8e20177 100644
--- a/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/Search/TestNumericRangeQuery64.cs
@@ -711,11 +711,7 @@ namespace Lucene.Net.Search
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSorting_8bit()
         {
             TestSorting(8);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestScorerPerf.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestScorerPerf.cs b/src/Lucene.Net.Tests/Search/TestScorerPerf.cs
index 0381812..c42c850 100644
--- a/src/Lucene.Net.Tests/Search/TestScorerPerf.cs
+++ b/src/Lucene.Net.Tests/Search/TestScorerPerf.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Attributes;
 using Lucene.Net.Documents;
 using Lucene.Net.Support;
 using System;
@@ -395,7 +396,7 @@ namespace Lucene.Net.Search
         // LUCENENET: There is no Timeout on NUnit for .NET Core.
         [Timeout(20000)] // LUCENENET TODO: Sometimes doesn't finish
 #endif
-        [Test]
+        [Test, HasTimeout]
         public virtual void TestConjunctions()
         {
             // test many small sets... the bugs will be found on boundary conditions

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestSearchAfter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestSearchAfter.cs b/src/Lucene.Net.Tests/Search/TestSearchAfter.cs
index 1bd0caa..1f32b6c 100644
--- a/src/Lucene.Net.Tests/Search/TestSearchAfter.cs
+++ b/src/Lucene.Net.Tests/Search/TestSearchAfter.cs
@@ -232,11 +232,7 @@ namespace Lucene.Net.Search
             base.TearDown();
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(90000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestQueries()
         {
             // LUCENENET specific: NUnit will crash with an OOM if we do the full test

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Search/TestSearcherManager.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Search/TestSearcherManager.cs b/src/Lucene.Net.Tests/Search/TestSearcherManager.cs
index 8af89f4..14d6a55 100644
--- a/src/Lucene.Net.Tests/Search/TestSearcherManager.cs
+++ b/src/Lucene.Net.Tests/Search/TestSearcherManager.cs
@@ -51,11 +51,7 @@ namespace Lucene.Net.Search
 
         private SearcherLifetimeManager.IPruner pruner;
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSearcherManager_Mem()
         {
             pruner = new SearcherLifetimeManager.PruneByAge(TEST_NIGHTLY ? TestUtil.NextInt(Random(), 1, 20) : 1);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Store/TestCopyBytes.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Store/TestCopyBytes.cs b/src/Lucene.Net.Tests/Store/TestCopyBytes.cs
index 25c8b3f..e311d63 100644
--- a/src/Lucene.Net.Tests/Store/TestCopyBytes.cs
+++ b/src/Lucene.Net.Tests/Store/TestCopyBytes.cs
@@ -36,11 +36,7 @@ namespace Lucene.Net.Store
             return unchecked((byte)((idx % 256) * (1 + (idx / 256))));
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestCopyBytesMem()
         {
             int num = AtLeast(10);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Store/TestDirectory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Store/TestDirectory.cs b/src/Lucene.Net.Tests/Store/TestDirectory.cs
index 9d514c1..fc52c59 100644
--- a/src/Lucene.Net.Tests/Store/TestDirectory.cs
+++ b/src/Lucene.Net.Tests/Store/TestDirectory.cs
@@ -61,11 +61,7 @@ namespace Lucene.Net.Store
 
         // test is occasionally very slow, i dont know why
         // try this seed: 7D7E036AD12927F5:93333EF9E6DE44DE
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestThreadSafety()
         {
             BaseDirectoryWrapper dir = NewDirectory();
@@ -178,11 +174,7 @@ namespace Lucene.Net.Store
 
         // Test that different instances of FSDirectory can coexist on the same
         // path, can read, write, and lock files.
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestDirectInstantiation()
         {
             DirectoryInfo path = CreateTempDir("testDirectInstantiation");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs b/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
index 329ae2a..002a473 100644
--- a/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
+++ b/src/Lucene.Net.Tests/Store/TestHugeRamFile.cs
@@ -63,11 +63,7 @@ namespace Lucene.Net.Store
 
         /// <summary>
         /// Test huge RAMFile with more than Integer.MAX_VALUE bytes. (LUCENE-957) </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestHugeFile()
         {
             var f = new DenseRAMFile();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Store/TestLockFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Store/TestLockFactory.cs b/src/Lucene.Net.Tests/Store/TestLockFactory.cs
index 6cfd74f..9fcaa65 100644
--- a/src/Lucene.Net.Tests/Store/TestLockFactory.cs
+++ b/src/Lucene.Net.Tests/Store/TestLockFactory.cs
@@ -199,11 +199,7 @@ namespace Lucene.Net.Store
         }
 
         // Verify: NativeFSLockFactory works correctly
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(int.MaxValue)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestNativeFSLockFactory()
         {
             var f = new NativeFSLockFactory(CreateTempDir("testNativeFsLockFactory"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Store/TestMultiMMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Store/TestMultiMMap.cs b/src/Lucene.Net.Tests/Store/TestMultiMMap.cs
index 3dcb59d..c91f9e2 100644
--- a/src/Lucene.Net.Tests/Store/TestMultiMMap.cs
+++ b/src/Lucene.Net.Tests/Store/TestMultiMMap.cs
@@ -317,11 +317,7 @@ namespace Lucene.Net.Store
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSeeking()
         {
             for (int i = 0; i < 10; i++)
@@ -353,11 +349,7 @@ namespace Lucene.Net.Store
 
         // note instead of seeking to offset and reading length, this opens slices at the
         // the various offset+length and just does readBytes.
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSlicedSeeking()
         {
             for (int i = 0; i < 10; i++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs b/src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs
index 8334937..37c37c1 100644
--- a/src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs
+++ b/src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs
@@ -1,3 +1,4 @@
+using Lucene.Net.Attributes;
 using Lucene.Net.Support.Threading;
 using Lucene.Net.Util;
 using NUnit.Framework;
@@ -133,7 +134,7 @@ namespace Lucene.Net
         // LUCENENET: There is no Timeout on NUnit for .NET Core.
         [Timeout(500)]
 #endif
-        [Test]
+        [Test, HasTimeout]
         public virtual void TestTimeout()
         {
             Thread.Sleep(5000);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs b/src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs
index 06c66bd..ec06077 100644
--- a/src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs
+++ b/src/Lucene.Net.Tests/Util/Fst/TestBytesStore.cs
@@ -33,11 +33,7 @@ namespace Lucene.Net.Util.Fst
     public class TestBytesStore : LuceneTestCase
     {
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(720000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestRandom()
         {
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
index dcabf46..2ffa46c 100644
--- a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
+++ b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs
@@ -268,11 +268,7 @@ namespace Lucene.Net.Util.Fst
         }
 
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(27000000)]
-#endif
-        [Test, LongRunningTest, HasTimeout] // 45 minutes to be on the safe side
+        [Test, LongRunningTest] // Can take up to 15 minutes
         public virtual void TestRandomWords()
         {
             // LUCENENET specific: NUnit will crash with an OOM if we do the full test

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
index efb0b77..0bad798 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestEliasFanoSequence.cs
@@ -304,11 +304,7 @@ namespace Lucene.Net.Util.Packed
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout, LuceneNetSpecific, Ignore("For debugging only")]
+        [Test, LongRunningTest, LuceneNetSpecific, Ignore("For debugging only")]
         public virtual void TestMonotoneSequencesLonger()
         {
             for (int s = 2; s < 4422; s++)
@@ -337,11 +333,7 @@ namespace Lucene.Net.Util.Packed
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout, LuceneNetSpecific, Ignore("For debugging only")]
+        [Test, LongRunningTest, LuceneNetSpecific, Ignore("For debugging only")]
         public virtual void TestStrictMonotoneSequencesLonger()
         {
             for (int s = 2; s < 4422; s++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs b/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
index 1e68326..89ab1b4 100644
--- a/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
+++ b/src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs
@@ -1125,11 +1125,7 @@ namespace Lucene.Net.Util.Packed
         }
 
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(180000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestAppendingLongBuffer()
         {
 
@@ -1486,11 +1482,7 @@ namespace Lucene.Net.Util.Packed
             }
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(180000)]
-#endif
-        [Test, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestBlockReaderOverflow()
         {
             long valueCount = TestUtil.NextLong(Random(), 1L + int.MaxValue, (long)int.MaxValue * 2);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/StressRamUsageEstimator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/StressRamUsageEstimator.cs b/src/Lucene.Net.Tests/Util/StressRamUsageEstimator.cs
index 72947a0..af364dc 100644
--- a/src/Lucene.Net.Tests/Util/StressRamUsageEstimator.cs
+++ b/src/Lucene.Net.Tests/Util/StressRamUsageEstimator.cs
@@ -122,11 +122,7 @@ namespace Lucene.Net.Util
             return s;
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSimpleByteArrays()
         {
             object[][] all = new object[0][];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs b/src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs
index 97cc233..5560fa5 100644
--- a/src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestDocIdBitSet.cs
@@ -64,11 +64,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Compare the content of the set against a <seealso cref="BitSet"/>.
         /// </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(150000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestAgainstBitSet()
         {
             base.TestAgainstBitSet();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestFixedBitSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestFixedBitSet.cs b/src/Lucene.Net.Tests/Util/TestFixedBitSet.cs
index 12b7405..5f7e1c5 100644
--- a/src/Lucene.Net.Tests/Util/TestFixedBitSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestFixedBitSet.cs
@@ -261,11 +261,7 @@ namespace Lucene.Net.Util
 
         // large enough to flush obvious bugs, small enough to run in <.5 sec as part of a
         // larger testsuite.
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public virtual void TestSmall()
         {
             DoRandomSets(AtLeast(1200), AtLeast(1000), 1);
@@ -552,11 +548,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Compare the content of the set against a <seealso cref="BitSet"/>.
         /// </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(150000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestAgainstBitSet()
         {
             base.TestAgainstBitSet();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestNumericUtils.cs b/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
index ea13443..78b3835 100644
--- a/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
+++ b/src/Lucene.Net.Tests/Util/TestNumericUtils.cs
@@ -338,11 +338,7 @@ namespace Lucene.Net.Util
             AssertLongRangeSplit(long.MinValue, long.MinValue + 0x10L, 4, true, Arrays.AsList(0x0000000000000010L, 0x0000000000000010L, 0x000000000000000L, 0x000000000000000L), Arrays.AsList(0, 4));
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public virtual void TestRandomSplit()
         {
             long num = (long)AtLeast(10);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs b/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs
index 204c93a..0d64cef 100644
--- a/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs
+++ b/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs
@@ -77,11 +77,7 @@ namespace Lucene.Net.Util
 #pragma warning restore 612, 618
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestIntermediateMerges()
         {
             // Sort 20 mb worth of data with 1mb buffer, binary merging.
@@ -89,11 +85,7 @@ namespace Lucene.Net.Util
             Assert.IsTrue(info.MergeRounds > 10);
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestSmallRandom()
         {
             // Sort 20 mb worth of data with 1mb buffer.
@@ -101,11 +93,7 @@ namespace Lucene.Net.Util
             Assert.AreEqual(1, sortInfo.MergeRounds);
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(300000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestLargerRandom()
         {
             // Sort 100MB worth of data with 15mb buffer.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestOpenBitSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestOpenBitSet.cs b/src/Lucene.Net.Tests/Util/TestOpenBitSet.cs
index 1aa49a1..626e7d0 100644
--- a/src/Lucene.Net.Tests/Util/TestOpenBitSet.cs
+++ b/src/Lucene.Net.Tests/Util/TestOpenBitSet.cs
@@ -551,11 +551,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Compare the content of the set against a <seealso cref="BitSet"/>.
         /// </summary>
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(150000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public override void TestAgainstBitSet()
         {
             base.TestAgainstBitSet();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestPagedBytes.cs b/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
index 38be652..2511cdd 100644
--- a/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
+++ b/src/Lucene.Net.Tests/Util/TestPagedBytes.cs
@@ -38,11 +38,7 @@ namespace Lucene.Net.Util
         // Writes random byte/s to "normal" file in dir, then
         // copies into PagedBytes and verifies with
         // PagedBytes.Reader:
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(90000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestDataInputOutput()
         {
             Random random = Random();
@@ -119,11 +115,7 @@ namespace Lucene.Net.Util
         // Writes random byte/s into PagedBytes via
         // .getDataOutput(), then verifies with
         // PagedBytes.getDataInput():
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(90000)]
-#endif
-        [Test, LongRunningTest, HasTimeout]
+        [Test, LongRunningTest]
         public virtual void TestDataInputOutput2()
         {
             Random random = Random();
@@ -189,11 +181,7 @@ namespace Lucene.Net.Util
 
         [Ignore("// memory hole")] 
         [Test]
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(120000)]
-#endif
-        [LongRunningTest, HasTimeout]
+        [LongRunningTest]
         public virtual void TestOverflow()
         {
             BaseDirectoryWrapper dir = NewFSDirectory(CreateTempDir("testOverflow"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3428d818/src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs b/src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs
index 57e5419..10cbfb7 100644
--- a/src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs
+++ b/src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs
@@ -197,11 +197,7 @@ namespace Lucene.Net.Util
             Assert.IsTrue(map.IsEmpty);
         }
 
-#if !NETSTANDARD
-        // LUCENENET: There is no Timeout on NUnit for .NET Core.
-        [Timeout(60000)]
-#endif
-        [Test, HasTimeout]
+        [Test]
         public virtual void TestConcurrentHashMap()
         {
             // don't make threadCount and keyCount random, otherwise easily OOMs or fails otherwise:


Mime
View raw message