[Lucene.Net] svn commit: r1294875 [38/45] - in /incubator/lucene.net/trunk: ./ build/ build/vs2010/contrib/ build/vs2010/test/ doc/ src/ src/contrib/Analyzers/ src/contrib/Analyzers/AR/ src/contrib/Analyzers/BR/ src/contrib/Analyzers/CJK/ src/contrib/Analyzers/Cn/ ...

[cc...@apache.org]

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterDelete.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterDelete.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterDelete.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterDelete.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using NUnit.Framework;
 
 using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
@@ -135,311 +135,284 @@ namespace Lucene.Net.Index
 		}
 		
 		// test the simple case
-		[Test]
-		public virtual void  TestSimpleCase()
-		{
-			System.String[] keywords = new System.String[]{"1", "2"};
-			System.String[] unindexed = new System.String[]{"Netherlands", "Italy"};
-			System.String[] unstored = new System.String[]{"Amsterdam has lots of bridges", "Venice has lots of canals"};
-			System.String[] text = new System.String[]{"Amsterdam", "Venice"};
-			
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				
-				Directory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetUseCompoundFile(true);
-				modifier.SetMaxBufferedDeleteTerms(1);
-				
-				for (int i = 0; i < keywords.Length; i++)
-				{
-					Document doc = new Document();
-					doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
-					doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
-					doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
-					doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
-					modifier.AddDocument(doc);
-				}
-				modifier.Optimize();
-				modifier.Commit();
-				
-				Term term = new Term("city", "Amsterdam");
-				int hitCount = GetHitCount(dir, term);
-				Assert.AreEqual(1, hitCount);
-				modifier.DeleteDocuments(term);
-				modifier.Commit();
-				hitCount = GetHitCount(dir, term);
-				Assert.AreEqual(0, hitCount);
-				
-				modifier.Close();
-				dir.Close();
-			}
-		}
-		
-		// test when delete terms only apply to disk segments
-		[Test]
-		public virtual void  TestNonRAMDelete()
-		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				
-				Directory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetMaxBufferedDocs(2);
-				modifier.SetMaxBufferedDeleteTerms(2);
-				
-				int id = 0;
-				int value_Renamed = 100;
-				
-				for (int i = 0; i < 7; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				modifier.Commit();
-				
-				Assert.AreEqual(0, modifier.GetNumBufferedDocuments());
-				Assert.IsTrue(0 < modifier.GetSegmentCount());
-				
-				modifier.Commit();
-				
-				IndexReader reader = IndexReader.Open(dir);
-				Assert.AreEqual(7, reader.NumDocs());
-				reader.Close();
-				
-				modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
-				
-				modifier.Commit();
-				
-				reader = IndexReader.Open(dir);
-				Assert.AreEqual(0, reader.NumDocs());
-				reader.Close();
-				modifier.Close();
-				dir.Close();
-			}
-		}
-		
-		[Test]
-		public virtual void  TestMaxBufferedDeletes()
-		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				Directory dir = new MockRAMDirectory();
-				IndexWriter writer = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				writer.SetMaxBufferedDeleteTerms(1);
-				writer.DeleteDocuments(new Term("foobar", "1"));
-				writer.DeleteDocuments(new Term("foobar", "1"));
-				writer.DeleteDocuments(new Term("foobar", "1"));
-				Assert.AreEqual(3, writer.GetFlushDeletesCount());
-				writer.Close();
-				dir.Close();
-			}
-		}
-		
-		// test when delete terms only apply to ram segments
+        [Test]
+        public virtual void TestSimpleCase()
+        {
+            System.String[] keywords = new System.String[] {"1", "2"};
+            System.String[] unindexed = new System.String[] {"Netherlands", "Italy"};
+            System.String[] unstored = new System.String[]
+                                           {"Amsterdam has lots of bridges", "Venice has lots of canals"};
+            System.String[] text = new System.String[] {"Amsterdam", "Venice"};
+
+            Directory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir,  new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+            modifier.SetUseCompoundFile(true);
+            modifier.SetMaxBufferedDeleteTerms(1);
+
+            for (int i = 0; i < keywords.Length; i++)
+            {
+                Document doc = new Document();
+                doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
+                doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
+                doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
+                doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
+                modifier.AddDocument(doc);
+            }
+            modifier.Optimize();
+            modifier.Commit();
+
+            Term term = new Term("city", "Amsterdam");
+            int hitCount = GetHitCount(dir, term);
+            Assert.AreEqual(1, hitCount);
+            modifier.DeleteDocuments(term);
+            modifier.Commit();
+            hitCount = GetHitCount(dir, term);
+            Assert.AreEqual(0, hitCount);
+
+            modifier.Close();
+            dir.Close();
+        }
+
+        // test when delete terms only apply to disk segments
+        [Test]
+        public virtual void TestNonRAMDelete()
+        {
+            Directory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true,
+                                                   IndexWriter.MaxFieldLength.UNLIMITED);
+            modifier.SetMaxBufferedDocs(2);
+            modifier.SetMaxBufferedDeleteTerms(2);
+
+            int id = 0;
+            int value_Renamed = 100;
+
+            for (int i = 0; i < 7; i++)
+            {
+                AddDoc(modifier, ++id, value_Renamed);
+            }
+            modifier.Commit();
+
+            Assert.AreEqual(0, modifier.GetNumBufferedDocuments());
+            Assert.IsTrue(0 < modifier.GetSegmentCount());
+
+            modifier.Commit();
+
+            IndexReader reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(7, reader.NumDocs());
+            reader.Close();
+
+            modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
+
+            modifier.Commit();
+
+            reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(0, reader.NumDocs());
+            reader.Close();
+            modifier.Close();
+            dir.Close();
+        }
+
+        [Test]
+        public virtual void TestMaxBufferedDeletes()
+        {
+            Directory dir = new MockRAMDirectory();
+            IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true,
+                                                 IndexWriter.MaxFieldLength.UNLIMITED);
+            writer.SetMaxBufferedDeleteTerms(1);
+            writer.DeleteDocuments(new Term("foobar", "1"));
+            writer.DeleteDocuments(new Term("foobar", "1"));
+            writer.DeleteDocuments(new Term("foobar", "1"));
+            Assert.AreEqual(3, writer.GetFlushDeletesCount());
+            writer.Close();
+            dir.Close();
+        }
+
+        // test when delete terms only apply to ram segments
 		[Test]
 		public virtual void  TestRAMDeletes()
 		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				for (int t = 0; t < 2; t++)
-				{
-					bool autoCommit = (0 == pass);
-					Directory dir = new MockRAMDirectory();
-					IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-					modifier.SetMaxBufferedDocs(4);
-					modifier.SetMaxBufferedDeleteTerms(4);
-					
-					int id = 0;
-					int value_Renamed = 100;
-					
-					AddDoc(modifier, ++id, value_Renamed);
-					if (0 == t)
-						modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
-					else
-						modifier.DeleteDocuments(new TermQuery(new Term("value", System.Convert.ToString(value_Renamed))));
-					AddDoc(modifier, ++id, value_Renamed);
-					if (0 == t)
-					{
-						modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
-						Assert.AreEqual(2, modifier.GetNumBufferedDeleteTerms());
-						Assert.AreEqual(1, modifier.GetBufferedDeleteTermsSize());
-					}
-					else
-						modifier.DeleteDocuments(new TermQuery(new Term("value", System.Convert.ToString(value_Renamed))));
-					
-					AddDoc(modifier, ++id, value_Renamed);
-					Assert.AreEqual(0, modifier.GetSegmentCount());
-					modifier.Flush();
-					
-					modifier.Commit();
-					
-					IndexReader reader = IndexReader.Open(dir);
-					Assert.AreEqual(1, reader.NumDocs());
-					
-					int hitCount = GetHitCount(dir, new Term("id", System.Convert.ToString(id)));
-					Assert.AreEqual(1, hitCount);
-					reader.Close();
-					modifier.Close();
-					dir.Close();
-				}
-			}
+            for (int t = 0; t < 2; t++)
+            {
+                Directory dir = new MockRAMDirectory();
+                IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+                modifier.SetMaxBufferedDocs(4);
+                modifier.SetMaxBufferedDeleteTerms(4);
+
+                int id = 0;
+                int value_Renamed = 100;
+
+                AddDoc(modifier, ++id, value_Renamed);
+                if (0 == t)
+                    modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
+                else
+                    modifier.DeleteDocuments(new TermQuery(new Term("value", System.Convert.ToString(value_Renamed))));
+                AddDoc(modifier, ++id, value_Renamed);
+                if (0 == t)
+                {
+                    modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
+                    Assert.AreEqual(2, modifier.GetNumBufferedDeleteTerms());
+                    Assert.AreEqual(1, modifier.GetBufferedDeleteTermsSize());
+                }
+                else
+                    modifier.DeleteDocuments(new TermQuery(new Term("value", System.Convert.ToString(value_Renamed))));
+
+                AddDoc(modifier, ++id, value_Renamed);
+                Assert.AreEqual(0, modifier.GetSegmentCount());
+                modifier.Commit();
+
+                modifier.Commit();
+
+                IndexReader reader = IndexReader.Open(dir, true);
+                Assert.AreEqual(1, reader.NumDocs());
+
+                int hitCount = GetHitCount(dir, new Term("id", System.Convert.ToString(id)));
+                Assert.AreEqual(1, hitCount);
+                reader.Close();
+                modifier.Close();
+                dir.Close();
+            }
 		}
 		
 		// test when delete terms apply to both disk and ram segments
-		[Test]
-		public virtual void  TestBothDeletes()
-		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				
-				Directory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetMaxBufferedDocs(100);
-				modifier.SetMaxBufferedDeleteTerms(100);
-				
-				int id = 0;
-				int value_Renamed = 100;
-				
-				for (int i = 0; i < 5; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				
-				value_Renamed = 200;
-				for (int i = 0; i < 5; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				modifier.Commit();
-				
-				for (int i = 0; i < 5; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
-				
-				modifier.Commit();
-				
-				IndexReader reader = IndexReader.Open(dir);
-				Assert.AreEqual(5, reader.NumDocs());
-				modifier.Close();
-			}
-		}
-		
-		// test that batched delete terms are flushed together
-		[Test]
-		public virtual void  TestBatchDeletes()
-		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				Directory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetMaxBufferedDocs(2);
-				modifier.SetMaxBufferedDeleteTerms(2);
-				
-				int id = 0;
-				int value_Renamed = 100;
-				
-				for (int i = 0; i < 7; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				modifier.Commit();
-				
-				IndexReader reader = IndexReader.Open(dir);
-				Assert.AreEqual(7, reader.NumDocs());
-				reader.Close();
-				
-				id = 0;
-				modifier.DeleteDocuments(new Term("id", System.Convert.ToString(++id)));
-				modifier.DeleteDocuments(new Term("id", System.Convert.ToString(++id)));
-				
-				modifier.Commit();
-				
-				reader = IndexReader.Open(dir);
-				Assert.AreEqual(5, reader.NumDocs());
-				reader.Close();
-				
-				Term[] terms = new Term[3];
-				for (int i = 0; i < terms.Length; i++)
-				{
-					terms[i] = new Term("id", System.Convert.ToString(++id));
-				}
-				modifier.DeleteDocuments(terms);
-				modifier.Commit();
-				reader = IndexReader.Open(dir);
-				Assert.AreEqual(2, reader.NumDocs());
-				reader.Close();
-				
-				modifier.Close();
-				dir.Close();
-			}
-		}
-		
-		// test deleteAll()
+        [Test]
+        public virtual void TestBothDeletes()
+        {
+            Directory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+            modifier.SetMaxBufferedDocs(100);
+            modifier.SetMaxBufferedDeleteTerms(100);
+
+            int id = 0;
+            int value_Renamed = 100;
+
+            for (int i = 0; i < 5; i++)
+            {
+                AddDoc(modifier, ++id, value_Renamed);
+            }
+
+            value_Renamed = 200;
+            for (int i = 0; i < 5; i++)
+            {
+                AddDoc(modifier, ++id, value_Renamed);
+            }
+            modifier.Commit();
+
+            for (int i = 0; i < 5; i++)
+            {
+                AddDoc(modifier, ++id, value_Renamed);
+            }
+            modifier.DeleteDocuments(new Term("value", System.Convert.ToString(value_Renamed)));
+
+            modifier.Commit();
+
+            IndexReader reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(5, reader.NumDocs());
+            modifier.Close();
+        }
+
+        // test that batched delete terms are flushed together
+        [Test]
+        public virtual void TestBatchDeletes()
+        {
+            Directory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true,
+                                                   IndexWriter.MaxFieldLength.UNLIMITED);
+            modifier.SetMaxBufferedDocs(2);
+            modifier.SetMaxBufferedDeleteTerms(2);
+
+            int id = 0;
+            int value_Renamed = 100;
+
+            for (int i = 0; i < 7; i++)
+            {
+                AddDoc(modifier, ++id, value_Renamed);
+            }
+            modifier.Commit();
+
+            IndexReader reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(7, reader.NumDocs());
+            reader.Close();
+
+            id = 0;
+            modifier.DeleteDocuments(new Term("id", System.Convert.ToString(++id)));
+            modifier.DeleteDocuments(new Term("id", System.Convert.ToString(++id)));
+
+            modifier.Commit();
+
+            reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(5, reader.NumDocs());
+            reader.Close();
+
+            Term[] terms = new Term[3];
+            for (int i = 0; i < terms.Length; i++)
+            {
+                terms[i] = new Term("id", System.Convert.ToString(++id));
+            }
+            modifier.DeleteDocuments(terms);
+            modifier.Commit();
+            reader = IndexReader.Open(dir, true);
+            Assert.AreEqual(2, reader.NumDocs());
+            reader.Close();
+
+            modifier.Close();
+            dir.Close();
+        }
+
+        // test deleteAll()
 		[Test]
 		public virtual void  TestDeleteAll()
 		{
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				Directory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetMaxBufferedDocs(2);
-				modifier.SetMaxBufferedDeleteTerms(2);
-				
-				int id = 0;
-				int value_Renamed = 100;
-				
-				for (int i = 0; i < 7; i++)
-				{
-					AddDoc(modifier, ++id, value_Renamed);
-				}
-				modifier.Commit();
-				
-				IndexReader reader = IndexReader.Open(dir);
-				Assert.AreEqual(7, reader.NumDocs());
-				reader.Close();
-				
-				// Add 1 doc (so we will have something buffered)
-				AddDoc(modifier, 99, value_Renamed);
-				
-				// Delete all
-				modifier.DeleteAll();
-				
-				// Delete all shouldn't be on disk yet
-				reader = IndexReader.Open(dir);
-				Assert.AreEqual(7, reader.NumDocs());
-				reader.Close();
-				
-				// Add a doc and update a doc (after the deleteAll, before the commit)
-				AddDoc(modifier, 101, value_Renamed);
-				UpdateDoc(modifier, 102, value_Renamed);
-				
-				// commit the delete all
-				modifier.Commit();
-				
-				// Validate there are no docs left
-				reader = IndexReader.Open(dir);
-				Assert.AreEqual(2, reader.NumDocs());
-				reader.Close();
-				
-				modifier.Close();
-				dir.Close();
-			}
+		    Directory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+		    modifier.SetMaxBufferedDocs(2);
+		    modifier.SetMaxBufferedDeleteTerms(2);
+
+		    int id = 0;
+		    int value_Renamed = 100;
+
+		    for (int i = 0; i < 7; i++)
+		    {
+		        AddDoc(modifier, ++id, value_Renamed);
+		    }
+		    modifier.Commit();
+
+		    IndexReader reader = IndexReader.Open(dir, true);
+		    Assert.AreEqual(7, reader.NumDocs());
+		    reader.Close();
+
+		    // Add 1 doc (so we will have something buffered)
+		    AddDoc(modifier, 99, value_Renamed);
+
+		    // Delete all
+		    modifier.DeleteAll();
+
+		    // Delete all shouldn't be on disk yet
+		    reader = IndexReader.Open(dir, true);
+		    Assert.AreEqual(7, reader.NumDocs());
+		    reader.Close();
+
+		    // Add a doc and update a doc (after the deleteAll, before the commit)
+		    AddDoc(modifier, 101, value_Renamed);
+		    UpdateDoc(modifier, 102, value_Renamed);
+
+		    // commit the delete all
+		    modifier.Commit();
+
+		    // Validate there are no docs left
+		    reader = IndexReader.Open(dir, true);
+		    Assert.AreEqual(2, reader.NumDocs());
+		    reader.Close();
+
+		    modifier.Close();
+		    dir.Close();
 		}
-		
-		// test rollback of deleteAll()
+
+        // test rollback of deleteAll()
 		[Test]
 		public virtual void  TestDeleteAllRollback()
 		{
 			Directory dir = new MockRAMDirectory();
-			IndexWriter modifier = new IndexWriter(dir, false, new WhitespaceAnalyzer(), true);
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
 			modifier.SetMaxBufferedDocs(2);
 			modifier.SetMaxBufferedDeleteTerms(2);
 			
@@ -453,8 +426,8 @@ namespace Lucene.Net.Index
 			modifier.Commit();
 			
 			AddDoc(modifier, ++id, value_Renamed);
-			
-			IndexReader reader = IndexReader.Open(dir);
+
+		    IndexReader reader = IndexReader.Open(dir, true);
 			Assert.AreEqual(7, reader.NumDocs());
 			reader.Close();
 			
@@ -466,7 +439,7 @@ namespace Lucene.Net.Index
 			modifier.Close();
 			
 			// Validate that the docs are still there
-			reader = IndexReader.Open(dir);
+		    reader = IndexReader.Open(dir, true);
 			Assert.AreEqual(7, reader.NumDocs());
 			reader.Close();
 			
@@ -479,7 +452,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestDeleteAllNRT()
 		{
 			Directory dir = new MockRAMDirectory();
-			IndexWriter modifier = new IndexWriter(dir, false, new WhitespaceAnalyzer(), true);
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
 			modifier.SetMaxBufferedDocs(2);
 			modifier.SetMaxBufferedDeleteTerms(2);
 			
@@ -512,7 +485,7 @@ namespace Lucene.Net.Index
 			modifier.Close();
 			
 			// Validate that the docs are still there
-			reader = IndexReader.Open(dir);
+		    reader = IndexReader.Open(dir, true);
 			Assert.AreEqual(7, reader.NumDocs());
 			reader.Close();
 			
@@ -541,7 +514,7 @@ namespace Lucene.Net.Index
 		
 		private int GetHitCount(Directory dir, Term term)
 		{
-			IndexSearcher searcher = new IndexSearcher(dir);
+		    IndexSearcher searcher = new IndexSearcher(dir, true);
 			int hitCount = searcher.Search(new TermQuery(term), null, 1000).TotalHits;
 			searcher.Close();
 			return hitCount;
@@ -562,376 +535,371 @@ namespace Lucene.Net.Index
 		/// <summary> Make sure if modifier tries to commit but hits disk full that modifier
 		/// remains consistent and usable. Similar to TestIndexReader.testDiskFull().
 		/// </summary>
-		private void  TestOperationsOnDiskFull(bool updates)
+        private void TestOperationsOnDiskFull(bool updates)
 		{
-			
-			bool debug = false;
-			Term searchTerm = new Term("content", "aaa");
-			int START_COUNT = 157;
-			int END_COUNT = 144;
-			
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				
-				// First build up a starting index:
-				MockRAMDirectory startDir = new MockRAMDirectory();
-				IndexWriter writer = new IndexWriter(startDir, autoCommit, new WhitespaceAnalyzer(), true);
-				for (int i = 0; i < 157; i++)
-				{
-					Document d = new Document();
-					d.Add(new Field("id", System.Convert.ToString(i), Field.Store.YES, Field.Index.NOT_ANALYZED));
-					d.Add(new Field("content", "aaa " + i, Field.Store.NO, Field.Index.ANALYZED));
-					writer.AddDocument(d);
-				}
-				writer.Close();
-				
-				long diskUsage = startDir.SizeInBytes();
-				long diskFree = diskUsage + 10;
-				
-				System.IO.IOException err = null;
-				
-				bool done = false;
-				
-				// Iterate w/ ever increasing free disk space:
-				while (!done)
-				{
-					MockRAMDirectory dir = new MockRAMDirectory(startDir);
-					dir.SetPreventDoubleWrite(false);
-					IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer());
-					
-					modifier.SetMaxBufferedDocs(1000); // use flush or close
-					modifier.SetMaxBufferedDeleteTerms(1000); // use flush or close
-					
-					// For each disk size, first try to commit against
-					// dir that will hit random IOExceptions & disk
-					// full; after, give it infinite disk space & turn
-					// off random IOExceptions & retry w/ same reader:
-					bool success = false;
-					
-					for (int x = 0; x < 2; x++)
-					{
-						
-						double rate = 0.1;
-						double diskRatio = ((double) diskFree) / diskUsage;
-						long thisDiskFree;
-						System.String testName;
-						
-						if (0 == x)
-						{
-							thisDiskFree = diskFree;
-							if (diskRatio >= 2.0)
-							{
-								rate /= 2;
-							}
-							if (diskRatio >= 4.0)
-							{
-								rate /= 2;
-							}
-							if (diskRatio >= 6.0)
-							{
-								rate = 0.0;
-							}
-							if (debug)
-							{
-								System.Console.Out.WriteLine("\ncycle: " + diskFree + " bytes");
-							}
-							testName = "disk full during reader.close() @ " + thisDiskFree + " bytes";
-						}
-						else
-						{
-							thisDiskFree = 0;
-							rate = 0.0;
-							if (debug)
-							{
-								System.Console.Out.WriteLine("\ncycle: same writer: unlimited disk space");
-							}
-							testName = "reader re-use after disk full";
-						}
-						
-						dir.SetMaxSizeInBytes(thisDiskFree);
-						dir.SetRandomIOExceptionRate(rate, diskFree);
-						
-						try
-						{
-							if (0 == x)
-							{
-								int docId = 12;
-								for (int i = 0; i < 13; i++)
-								{
-									if (updates)
-									{
-										Document d = new Document();
-										d.Add(new Field("id", System.Convert.ToString(i), Field.Store.YES, Field.Index.NOT_ANALYZED));
-										d.Add(new Field("content", "bbb " + i, Field.Store.NO, Field.Index.ANALYZED));
-										modifier.UpdateDocument(new Term("id", System.Convert.ToString(docId)), d);
-									}
-									else
-									{
-										// deletes
-										modifier.DeleteDocuments(new Term("id", System.Convert.ToString(docId)));
-										// modifier.setNorm(docId, "contents", (float)2.0);
-									}
-									docId += 12;
-								}
-							}
-							modifier.Close();
-							success = true;
-							if (0 == x)
-							{
-								done = true;
-							}
-						}
-						catch (System.IO.IOException e)
-						{
-							if (debug)
-							{
-								System.Console.Out.WriteLine("  hit IOException: " + e);
-								System.Console.Out.WriteLine(e.StackTrace);
-							}
-							err = e;
-							if (1 == x)
-							{
-								System.Console.Error.WriteLine(e.StackTrace);
-								Assert.Fail(testName + " hit IOException after disk space was freed up");
-							}
-						}
-						
-						// If the close() succeeded, make sure there are
-						// no unreferenced files.
-                        if (success)
-                        {
-                            Lucene.Net.Util._TestUtil.CheckIndex(dir);
-                            TestIndexWriter.AssertNoUnreferencedFiles(dir, "after writer.close");
-                        }
-						
-						// Finally, verify index is not corrupt, and, if
-						// we succeeded, we see all docs changed, and if
-						// we failed, we see either all docs or no docs
-						// changed (transactional semantics):
-						IndexReader newReader = null;
-						try
-						{
-							newReader = IndexReader.Open(dir);
-						}
-						catch (System.IO.IOException e)
-						{
-							System.Console.Error.WriteLine(e.StackTrace);
-							Assert.Fail(testName + ":exception when creating IndexReader after disk full during close: " + e);
-						}
-						
-						IndexSearcher searcher = new IndexSearcher(newReader);
-						ScoreDoc[] hits = null;
-						try
-						{
-							hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
-						}
-						catch (System.IO.IOException e)
-						{
-							System.Console.Error.WriteLine(e.StackTrace);
-							Assert.Fail(testName + ": exception when searching: " + e);
-						}
-						int result2 = hits.Length;
-						if (success)
-						{
-							if (x == 0 && result2 != END_COUNT)
-							{
-								Assert.Fail(testName + ": method did not throw exception but hits.length for search on term 'aaa' is " + result2 + " instead of expected " + END_COUNT);
-							}
-							else if (x == 1 && result2 != START_COUNT && result2 != END_COUNT)
-							{
-								// It's possible that the first exception was
-								// "recoverable" wrt pending deletes, in which
-								// case the pending deletes are retained and
-								// then re-flushing (with plenty of disk
-								// space) will succeed in flushing the
-								// deletes:
-								Assert.Fail(testName + ": method did not throw exception but hits.length for search on term 'aaa' is " + result2 + " instead of expected " + START_COUNT + " or " + END_COUNT);
-							}
-						}
-						else
-						{
-							// On hitting exception we still may have added
-							// all docs:
-							if (result2 != START_COUNT && result2 != END_COUNT)
-							{
-								System.Console.Error.WriteLine(err.StackTrace);
-								Assert.Fail(testName + ": method did throw exception but hits.length for search on term 'aaa' is " + result2 + " instead of expected " + START_COUNT + " or " + END_COUNT);
-							}
-						}
-						
-						searcher.Close();
-						newReader.Close();
-						
-						if (result2 == END_COUNT)
-						{
-							break;
-						}
-					}
-					
-					dir.Close();
-					
-					// Try again with 10 more bytes of free space:
-					diskFree += 10;
-				}
-			}
+
+		    bool debug = false;
+		    Term searchTerm = new Term("content", "aaa");
+		    int START_COUNT = 157;
+		    int END_COUNT = 144;
+
+		    // First build up a starting index:
+		    MockRAMDirectory startDir = new MockRAMDirectory();
+            IndexWriter writer = new IndexWriter(startDir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+		    for (int i = 0; i < 157; i++)
+		    {
+		        Document d = new Document();
+		        d.Add(new Field("id", System.Convert.ToString(i), Field.Store.YES, Field.Index.NOT_ANALYZED));
+		        d.Add(new Field("content", "aaa " + i, Field.Store.NO, Field.Index.ANALYZED));
+		        writer.AddDocument(d);
+		    }
+		    writer.Close();
+
+		    long diskUsage = startDir.SizeInBytes();
+		    long diskFree = diskUsage + 10;
+
+		    System.IO.IOException err = null;
+
+		    bool done = false;
+
+		    // Iterate w/ ever increasing free disk space:
+		    while (!done)
+		    {
+		        MockRAMDirectory dir = new MockRAMDirectory(startDir);
+		        dir.SetPreventDoubleWrite(false);
+                IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
+
+		        modifier.SetMaxBufferedDocs(1000); // use flush or close
+		        modifier.SetMaxBufferedDeleteTerms(1000); // use flush or close
+
+		        // For each disk size, first try to commit against
+		        // dir that will hit random IOExceptions & disk
+		        // full; after, give it infinite disk space & turn
+		        // off random IOExceptions & retry w/ same reader:
+		        bool success = false;
+
+		        for (int x = 0; x < 2; x++)
+		        {
+
+		            double rate = 0.1;
+		            double diskRatio = ((double) diskFree)/diskUsage;
+		            long thisDiskFree;
+		            System.String testName;
+
+		            if (0 == x)
+		            {
+		                thisDiskFree = diskFree;
+		                if (diskRatio >= 2.0)
+		                {
+		                    rate /= 2;
+		                }
+		                if (diskRatio >= 4.0)
+		                {
+		                    rate /= 2;
+		                }
+		                if (diskRatio >= 6.0)
+		                {
+		                    rate = 0.0;
+		                }
+		                if (debug)
+		                {
+		                    System.Console.Out.WriteLine("\ncycle: " + diskFree + " bytes");
+		                }
+		                testName = "disk full during reader.close() @ " + thisDiskFree + " bytes";
+		            }
+		            else
+		            {
+		                thisDiskFree = 0;
+		                rate = 0.0;
+		                if (debug)
+		                {
+		                    System.Console.Out.WriteLine("\ncycle: same writer: unlimited disk space");
+		                }
+		                testName = "reader re-use after disk full";
+		            }
+
+		            dir.SetMaxSizeInBytes(thisDiskFree);
+		            dir.SetRandomIOExceptionRate(rate, diskFree);
+
+		            try
+		            {
+		                if (0 == x)
+		                {
+		                    int docId = 12;
+		                    for (int i = 0; i < 13; i++)
+		                    {
+		                        if (updates)
+		                        {
+		                            Document d = new Document();
+		                            d.Add(new Field("id", System.Convert.ToString(i), Field.Store.YES,
+		                                            Field.Index.NOT_ANALYZED));
+		                            d.Add(new Field("content", "bbb " + i, Field.Store.NO, Field.Index.ANALYZED));
+		                            modifier.UpdateDocument(new Term("id", System.Convert.ToString(docId)), d);
+		                        }
+		                        else
+		                        {
+		                            // deletes
+		                            modifier.DeleteDocuments(new Term("id", System.Convert.ToString(docId)));
+		                            // modifier.setNorm(docId, "contents", (float)2.0);
+		                        }
+		                        docId += 12;
+		                    }
+		                }
+		                modifier.Close();
+		                success = true;
+		                if (0 == x)
+		                {
+		                    done = true;
+		                }
+		            }
+		            catch (System.IO.IOException e)
+		            {
+		                if (debug)
+		                {
+		                    System.Console.Out.WriteLine("  hit IOException: " + e);
+		                    System.Console.Out.WriteLine(e.StackTrace);
+		                }
+		                err = e;
+		                if (1 == x)
+		                {
+		                    System.Console.Error.WriteLine(e.StackTrace);
+		                    Assert.Fail(testName + " hit IOException after disk space was freed up");
+		                }
+		            }
+
+		            // If the close() succeeded, make sure there are
+		            // no unreferenced files.
+		            if (success)
+		            {
+		                Lucene.Net.Util._TestUtil.CheckIndex(dir);
+		                TestIndexWriter.AssertNoUnreferencedFiles(dir, "after writer.close");
+		            }
+
+		            // Finally, verify index is not corrupt, and, if
+		            // we succeeded, we see all docs changed, and if
+		            // we failed, we see either all docs or no docs
+		            // changed (transactional semantics):
+		            IndexReader newReader = null;
+		            try
+		            {
+		                newReader = IndexReader.Open(dir, true);
+		            }
+		            catch (System.IO.IOException e)
+		            {
+		                System.Console.Error.WriteLine(e.StackTrace);
+		                Assert.Fail(testName + ":exception when creating IndexReader after disk full during close: " + e);
+		            }
+
+		            IndexSearcher searcher = new IndexSearcher(newReader);
+		            ScoreDoc[] hits = null;
+		            try
+		            {
+		                hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
+		            }
+		            catch (System.IO.IOException e)
+		            {
+		                System.Console.Error.WriteLine(e.StackTrace);
+		                Assert.Fail(testName + ": exception when searching: " + e);
+		            }
+		            int result2 = hits.Length;
+		            if (success)
+		            {
+		                if (x == 0 && result2 != END_COUNT)
+		                {
+		                    Assert.Fail(testName +
+		                                ": method did not throw exception but hits.length for search on term 'aaa' is " +
+		                                result2 + " instead of expected " + END_COUNT);
+		                }
+		                else if (x == 1 && result2 != START_COUNT && result2 != END_COUNT)
+		                {
+		                    // It's possible that the first exception was
+		                    // "recoverable" wrt pending deletes, in which
+		                    // case the pending deletes are retained and
+		                    // then re-flushing (with plenty of disk
+		                    // space) will succeed in flushing the
+		                    // deletes:
+		                    Assert.Fail(testName +
+		                                ": method did not throw exception but hits.length for search on term 'aaa' is " +
+		                                result2 + " instead of expected " + START_COUNT + " or " + END_COUNT);
+		                }
+		            }
+		            else
+		            {
+		                // On hitting exception we still may have added
+		                // all docs:
+		                if (result2 != START_COUNT && result2 != END_COUNT)
+		                {
+		                    System.Console.Error.WriteLine(err.StackTrace);
+		                    Assert.Fail(testName + ": method did throw exception but hits.length for search on term 'aaa' is " +
+		                                result2 + " instead of expected " + START_COUNT + " or " + END_COUNT);
+		                }
+		            }
+
+		            searcher.Close();
+		            newReader.Close();
+
+		            if (result2 == END_COUNT)
+		            {
+		                break;
+		            }
+		        }
+
+		        dir.Close();
+
+		        // Try again with 10 more bytes of free space:
+		        diskFree += 10;
+		    }
 		}
-		
-		// This test tests that buffered deletes are cleared when
+
+        // This test tests that buffered deletes are cleared when
 		// an Exception is hit during flush.
-		[Test]
-		public virtual void  TestErrorAfterApplyDeletes()
-		{
-			
-			MockRAMDirectory.Failure failure = new AnonymousClassFailure(this);
-			
-			// create a couple of files
-			
-			System.String[] keywords = new System.String[]{"1", "2"};
-			System.String[] unindexed = new System.String[]{"Netherlands", "Italy"};
-			System.String[] unstored = new System.String[]{"Amsterdam has lots of bridges", "Venice has lots of canals"};
-			System.String[] text = new System.String[]{"Amsterdam", "Venice"};
-			
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				MockRAMDirectory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				modifier.SetUseCompoundFile(true);
-				modifier.SetMaxBufferedDeleteTerms(2);
-				
-				dir.FailOn(failure.Reset());
-				
-				for (int i = 0; i < keywords.Length; i++)
-				{
-					Document doc = new Document();
-					doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
-					doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
-					doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
-					doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
-					modifier.AddDocument(doc);
-				}
-				// flush (and commit if ac)
-				
-				modifier.Optimize();
-				modifier.Commit();
-				
-				// one of the two files hits
-				
-				Term term = new Term("city", "Amsterdam");
-				int hitCount = GetHitCount(dir, term);
-				Assert.AreEqual(1, hitCount);
-				
-				// open the writer again (closed above)
-				
-				// delete the doc
-				// max buf del terms is two, so this is buffered
-				
-				modifier.DeleteDocuments(term);
-				
-				// add a doc (needed for the !ac case; see below)
-				// doc remains buffered
-				
-				Document doc2 = new Document();
-				modifier.AddDocument(doc2);
-				
-				// commit the changes, the buffered deletes, and the new doc
-				
-				// The failure object will fail on the first write after the del
-				// file gets created when processing the buffered delete
-				
-				// in the ac case, this will be when writing the new segments
-				// files so we really don't need the new doc, but it's harmless
-				
-				// in the !ac case, a new segments file won't be created but in
-				// this case, creation of the cfs file happens next so we need
-				// the doc (to test that it's okay that we don't lose deletes if
-				// failing while creating the cfs file)
-				
-				bool failed = false;
-				try
-				{
-					modifier.Commit();
-				}
-				catch (System.IO.IOException ioe)
-				{
-					failed = true;
-				}
-				
-				Assert.IsTrue(failed);
-				
-				// The commit above failed, so we need to retry it (which will
-				// succeed, because the failure is a one-shot)
-				
-				modifier.Commit();
-				
-				hitCount = GetHitCount(dir, term);
-				
-				// Make sure the delete was successfully flushed:
-				Assert.AreEqual(0, hitCount);
-				
-				modifier.Close();
-				dir.Close();
-			}
-		}
-		
-		// This test tests that the files created by the docs writer before
+        [Test]
+        public virtual void TestErrorAfterApplyDeletes()
+        {
+            MockRAMDirectory.Failure failure = new AnonymousClassFailure(this);
+
+            // create a couple of files
+
+            System.String[] keywords = new System.String[] {"1", "2"};
+            System.String[] unindexed = new System.String[] {"Netherlands", "Italy"};
+            System.String[] unstored = new System.String[]
+                                           {"Amsterdam has lots of bridges", "Venice has lots of canals"};
+            System.String[] text = new System.String[] {"Amsterdam", "Venice"};
+
+            MockRAMDirectory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+            modifier.SetUseCompoundFile(true);
+            modifier.SetMaxBufferedDeleteTerms(2);
+
+            dir.FailOn(failure.Reset());
+
+            for (int i = 0; i < keywords.Length; i++)
+            {
+                Document doc = new Document();
+                doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
+                doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
+                doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
+                doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
+                modifier.AddDocument(doc);
+            }
+            // flush (and commit if ac)
+
+            modifier.Optimize();
+            modifier.Commit();
+
+            // one of the two files hits
+
+            Term term = new Term("city", "Amsterdam");
+            int hitCount = GetHitCount(dir, term);
+            Assert.AreEqual(1, hitCount);
+
+            // open the writer again (closed above)
+
+            // delete the doc
+            // max buf del terms is two, so this is buffered
+
+            modifier.DeleteDocuments(term);
+
+            // add a doc (needed for the !ac case; see below)
+            // doc remains buffered
+
+            Document doc2 = new Document();
+            modifier.AddDocument(doc2);
+
+            // commit the changes, the buffered deletes, and the new doc
+
+            // The failure object will fail on the first write after the del
+            // file gets created when processing the buffered delete
+
+            // in the ac case, this will be when writing the new segments
+            // files so we really don't need the new doc, but it's harmless
+
+            // in the !ac case, a new segments file won't be created but in
+            // this case, creation of the cfs file happens next so we need
+            // the doc (to test that it's okay that we don't lose deletes if
+            // failing while creating the cfs file)
+
+            bool failed = false;
+            try
+            {
+                modifier.Commit();
+            }
+            catch (System.IO.IOException ioe)
+            {
+                failed = true;
+            }
+
+            Assert.IsTrue(failed);
+
+            // The commit above failed, so we need to retry it (which will
+            // succeed, because the failure is a one-shot)
+
+            modifier.Commit();
+
+            hitCount = GetHitCount(dir, term);
+
+            // Make sure the delete was successfully flushed:
+            Assert.AreEqual(0, hitCount);
+
+            modifier.Close();
+            dir.Close();
+        }
+
+        // This test tests that the files created by the docs writer before
 		// a segment is written are cleaned up if there's an i/o error
-		
-		[Test]
-		public virtual void  TestErrorInDocsWriterAdd()
-		{
-			
-			MockRAMDirectory.Failure failure = new AnonymousClassFailure1(this);
-			
-			// create a couple of files
-			
-			System.String[] keywords = new System.String[]{"1", "2"};
-			System.String[] unindexed = new System.String[]{"Netherlands", "Italy"};
-			System.String[] unstored = new System.String[]{"Amsterdam has lots of bridges", "Venice has lots of canals"};
-			System.String[] text = new System.String[]{"Amsterdam", "Venice"};
-			
-			for (int pass = 0; pass < 2; pass++)
-			{
-				bool autoCommit = (0 == pass);
-				MockRAMDirectory dir = new MockRAMDirectory();
-				IndexWriter modifier = new IndexWriter(dir, autoCommit, new WhitespaceAnalyzer(), true);
-				
-				dir.FailOn(failure.Reset());
-				
-				for (int i = 0; i < keywords.Length; i++)
-				{
-					Document doc = new Document();
-					doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
-					doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
-					doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
-					doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
-					try
-					{
-						modifier.AddDocument(doc);
-					}
-					catch (System.IO.IOException io)
-					{
-						break;
-					}
-				}
-				
-				System.String[] startFiles = dir.ListAll();
-				SegmentInfos infos = new SegmentInfos();
-				infos.Read(dir);
-				new IndexFileDeleter(dir, new KeepOnlyLastCommitDeletionPolicy(), infos, null, null,null);
-				System.String[] endFiles = dir.ListAll();
-				
-				if (!SupportClass.CollectionsHelper.CompareStringArrays(startFiles, endFiles))
-				{
-					Assert.Fail("docswriter abort() failed to delete unreferenced files:\n  before delete:\n    " + ArrayToString(startFiles) + "\n  after delete:\n    " + ArrayToString(endFiles));
-				}
-				
-				modifier.Close();
-			}
-		}
-		
-		private System.String ArrayToString(System.String[] l)
+
+        [Test]
+        public virtual void TestErrorInDocsWriterAdd()
+        {
+
+            MockRAMDirectory.Failure failure = new AnonymousClassFailure1(this);
+
+            // create a couple of files
+
+            System.String[] keywords = new System.String[] {"1", "2"};
+            System.String[] unindexed = new System.String[] {"Netherlands", "Italy"};
+            System.String[] unstored = new System.String[]
+                                           {"Amsterdam has lots of bridges", "Venice has lots of canals"};
+            System.String[] text = new System.String[] {"Amsterdam", "Venice"};
+
+            MockRAMDirectory dir = new MockRAMDirectory();
+            IndexWriter modifier = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
+
+            dir.FailOn(failure.Reset());
+
+            for (int i = 0; i < keywords.Length; i++)
+            {
+                Document doc = new Document();
+                doc.Add(new Field("id", keywords[i], Field.Store.YES, Field.Index.NOT_ANALYZED));
+                doc.Add(new Field("country", unindexed[i], Field.Store.YES, Field.Index.NO));
+                doc.Add(new Field("contents", unstored[i], Field.Store.NO, Field.Index.ANALYZED));
+                doc.Add(new Field("city", text[i], Field.Store.YES, Field.Index.ANALYZED));
+                try
+                {
+                    modifier.AddDocument(doc);
+                }
+                catch (System.IO.IOException io)
+                {
+                    break;
+                }
+            }
+
+            System.String[] startFiles = dir.ListAll();
+            SegmentInfos infos = new SegmentInfos();
+            infos.Read(dir);
+            new IndexFileDeleter(dir, new KeepOnlyLastCommitDeletionPolicy(), infos, null, null, null);
+            System.String[] endFiles = dir.ListAll();
+
+            if (!CollectionsHelper.CompareStringArrays(startFiles, endFiles))
+            {
+                Assert.Fail("docswriter abort() failed to delete unreferenced files:\n  before delete:\n    " +
+                            ArrayToString(startFiles) + "\n  after delete:\n    " + ArrayToString(endFiles));
+            }
+
+            modifier.Close();
+        }
+
+        private System.String ArrayToString(System.String[] l)
 		{
 			System.String s = "";
 			for (int i = 0; i < l.Length; i++)

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterExceptions.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterExceptions.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterExceptions.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterExceptions.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using NUnit.Framework;
 
 using Analyzer = Lucene.Net.Analysis.Analyzer;
@@ -48,7 +48,7 @@ namespace Lucene.Net.Index
             return tvSettings[random.Next(tvSettings.Length)];
         }
 		
-		private class IndexerThread:SupportClass.ThreadClass
+		private class IndexerThread:ThreadClass
 		{
 			private void  InitBlock(TestIndexWriterExceptions enclosingInstance)
 			{
@@ -110,7 +110,7 @@ namespace Lucene.Net.Index
 					{
 						if (Lucene.Net.Index.TestIndexWriterExceptions.DEBUG)
 						{
-							System.Console.Out.WriteLine(SupportClass.ThreadClass.CurrentThread().Name + ": EXC: ");
+							System.Console.Out.WriteLine(ThreadClass.CurrentThread().Name + ": EXC: ");
 							System.Console.Out.WriteLine(re.StackTrace);
 						}
 						try
@@ -119,7 +119,7 @@ namespace Lucene.Net.Index
 						}
 						catch (System.IO.IOException ioe)
 						{
-							System.Console.Out.WriteLine(SupportClass.ThreadClass.Current().Name + ": unexpected exception1");
+							System.Console.Out.WriteLine(ThreadClass.Current().Name + ": unexpected exception1");
 							System.Console.Out.WriteLine(ioe.StackTrace);
 							failure = ioe;
 							break;
@@ -127,7 +127,7 @@ namespace Lucene.Net.Index
 					}
 					catch (System.Exception t)
 					{
-						System.Console.Out.WriteLine(SupportClass.ThreadClass.Current().Name + ": unexpected exception2");
+						System.Console.Out.WriteLine(ThreadClass.Current().Name + ": unexpected exception2");
 						System.Console.Out.WriteLine(t.StackTrace);
 						failure = t;
 						break;
@@ -144,7 +144,7 @@ namespace Lucene.Net.Index
 					}
 					catch (System.Exception t)
 					{
-						System.Console.Out.WriteLine(SupportClass.ThreadClass.Current().Name + ": unexpected exception3");
+						System.Console.Out.WriteLine(ThreadClass.Current().Name + ": unexpected exception3");
 						System.Console.Out.WriteLine(t.StackTrace);
 						failure = t;
 						break;
@@ -183,10 +183,10 @@ namespace Lucene.Net.Index
 				{
 					if (Lucene.Net.Index.TestIndexWriterExceptions.DEBUG)
 					{
-						System.Console.Out.WriteLine(SupportClass.ThreadClass.Current().Name + ": NOW FAIL: " + name);
+						System.Console.Out.WriteLine(ThreadClass.Current().Name + ": NOW FAIL: " + name);
 						//new Throwable().printStackTrace(System.out);
 					}
-					throw new System.SystemException(SupportClass.ThreadClass.Current().Name + ": intentionally failing at " + name);
+					throw new System.SystemException(ThreadClass.Current().Name + ": intentionally failing at " + name);
 				}
 				return true;
 			}
@@ -232,7 +232,7 @@ namespace Lucene.Net.Index
 			}
 			
 			// Confirm that when doc hits exception partway through tokenization, it's deleted:
-			IndexReader r2 = IndexReader.Open(dir);
+			IndexReader r2 = IndexReader.Open(dir, true);
 			int count = r2.DocFreq(new Term("content4", "aaa"));
 			int count2 = r2.DocFreq(new Term("content4", "ddd"));
 			Assert.AreEqual(count, count2);
@@ -289,7 +289,7 @@ namespace Lucene.Net.Index
 			}
 			
 			// Confirm that when doc hits exception partway through tokenization, it's deleted:
-			IndexReader r2 = IndexReader.Open(dir);
+		    IndexReader r2 = IndexReader.Open(dir, true);
 			int count = r2.DocFreq(new Term("content4", "aaa"));
 			int count2 = r2.DocFreq(new Term("content4", "ddd"));
 			Assert.AreEqual(count, count2);

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterLockRelease.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterLockRelease.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterLockRelease.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterLockRelease.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,8 @@
  */
 
 using System;
-
+using Lucene.Net.Store;
+using Lucene.Net.Support;
 using NUnit.Framework;
 
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
@@ -35,7 +36,7 @@ namespace Lucene.Net.Index
     [TestFixture]
 	public class TestIndexWriterLockRelease:LuceneTestCase
 	{
-		private System.IO.FileInfo __test_dir;
+		private System.IO.DirectoryInfo __test_dir;
 		
 		[SetUp]
 		public override void  SetUp()
@@ -43,8 +44,8 @@ namespace Lucene.Net.Index
 			base.SetUp();
 			if (this.__test_dir == null)
 			{
-				System.String tmp_dir = SupportClass.AppSettings.Get("java.io.tmpdir", "tmp");
-				this.__test_dir = new System.IO.FileInfo(System.IO.Path.Combine(tmp_dir, "testIndexWriter"));
+				System.String tmp_dir = AppSettings.Get("java.io.tmpdir", "tmp");
+				this.__test_dir = new System.IO.DirectoryInfo(System.IO.Path.Combine(tmp_dir, "testIndexWriter"));
 				
 				bool tmpBool;
 				if (System.IO.File.Exists(this.__test_dir.FullName))
@@ -79,7 +80,7 @@ namespace Lucene.Net.Index
 			base.TearDown();
 			if (this.__test_dir != null)
 			{
-				System.IO.FileInfo[] files = SupportClass.FileSupport.GetFiles(this.__test_dir);
+				System.IO.FileInfo[] files = FileSupport.GetFiles(this.__test_dir);
 				
 				for (int i = 0; i < files.Length; ++i)
 				{
@@ -126,21 +127,25 @@ namespace Lucene.Net.Index
 		public virtual void  TestIndexWriterLockRelease_Renamed()
 		{
 			IndexWriter im;
-			
-			try
-			{
-				im = new IndexWriter(this.__test_dir, new Lucene.Net.Analysis.Standard.StandardAnalyzer(), false, IndexWriter.MaxFieldLength.LIMITED);
-			}
-			catch (System.IO.FileNotFoundException e)
-			{
-				try
-				{
-					im = new IndexWriter(this.__test_dir, new Lucene.Net.Analysis.Standard.StandardAnalyzer(), false, IndexWriter.MaxFieldLength.LIMITED);
-				}
-				catch (System.IO.FileNotFoundException e1)
-				{
-				}
-			}
+		    FSDirectory dir = FSDirectory.Open(this.__test_dir);
+            try
+            {
+                im = new IndexWriter(dir, new Lucene.Net.Analysis.Standard.StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
+            }
+            catch (System.IO.FileNotFoundException e)
+            {
+                try
+                {
+                    im = new IndexWriter(dir, new Lucene.Net.Analysis.Standard.StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
+                }
+                catch (System.IO.FileNotFoundException e1)
+                {
+                }
+            }
+            finally
+            {
+                dir.Close();
+            }
 		}
 	}
 }
\ No newline at end of file

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMergePolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMergePolicy.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMergePolicy.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMergePolicy.cs Tue Feb 28 22:43:08 2012
@@ -145,7 +145,7 @@ namespace Lucene.Net.Index
 		{
 			Directory dir = new RAMDirectory();
 			
-			IndexWriter writer = new IndexWriter(dir, true, new WhitespaceAnalyzer(), true);
+			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
 			writer.SetMaxBufferedDocs(101);
 			writer.SetMergeFactor(101);
 			writer.SetMergePolicy(new LogDocMergePolicy(writer));
@@ -161,7 +161,7 @@ namespace Lucene.Net.Index
 				}
 				writer.Close();
 				
-				writer = new IndexWriter(dir, true, new WhitespaceAnalyzer(), false);
+				writer = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.UNLIMITED);
 				writer.SetMaxBufferedDocs(101);
 				writer.SetMergeFactor(101);
 				writer.SetMergePolicy(new LogDocMergePolicy(writer));
@@ -182,6 +182,9 @@ namespace Lucene.Net.Index
 			{
 				AddDoc(writer);
 			}
+		    writer.Commit();
+		    ((ConcurrentMergeScheduler) writer.GetMergeScheduler()).Sync();
+		    writer.Commit();
 			CheckInvariants(writer);
 			
 			writer.Close();
@@ -193,7 +196,7 @@ namespace Lucene.Net.Index
 		{
 			Directory dir = new RAMDirectory();
 			
-			IndexWriter writer = new IndexWriter(dir, true, new WhitespaceAnalyzer(), true);
+			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
 			writer.SetMergePolicy(new LogDocMergePolicy(writer));
 			writer.SetMaxBufferedDocs(10);
 			writer.SetMergeFactor(100);
@@ -204,12 +207,12 @@ namespace Lucene.Net.Index
 				CheckInvariants(writer);
 			}
 			writer.Close();
-			
-			IndexReader reader = IndexReader.Open(dir);
+
+		    IndexReader reader = IndexReader.Open(dir, false);
 			reader.DeleteDocuments(new Term("content", "aaa"));
 			reader.Close();
 			
-			writer = new IndexWriter(dir, true, new WhitespaceAnalyzer(), false);
+			writer = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.UNLIMITED);
 			writer.SetMergePolicy(new LogDocMergePolicy(writer));
 			writer.SetMaxBufferedDocs(10);
 			writer.SetMergeFactor(5);
@@ -219,8 +222,11 @@ namespace Lucene.Net.Index
 			{
 				AddDoc(writer);
 			}
+		    writer.Commit();
+            ((ConcurrentMergeScheduler)writer.GetMergeScheduler()).Sync();
+		    writer.Commit();
 			CheckInvariants(writer);
-			Assert.AreEqual(10, writer.DocCount());
+			Assert.AreEqual(10, writer.MaxDoc());
 			
 			writer.Close();
 		}
@@ -260,7 +266,7 @@ namespace Lucene.Net.Index
 				{
 					if (upperBound * mergeFactor <= maxMergeDocs)
 					{
-						Assert.IsTrue(numSegments < mergeFactor);
+                        Assert.IsTrue(numSegments < mergeFactor, "maxMergeDocs=" + maxMergeDocs + "; numSegments=" + numSegments + "; upperBound=" + upperBound + "; mergeFactor=" + mergeFactor);
 					}
 					
 					do 

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMerging.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMerging.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMerging.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterMerging.cs Tue Feb 28 22:43:08 2012
@@ -34,7 +34,7 @@ namespace Lucene.Net.Index
 	public class TestIndexWriterMerging:LuceneTestCase
 	{
 		
-		/// <summary> Tests that index merging (specifically addIndexes()) doesn't
+		/// <summary> Tests that index merging (specifically AddIndexesNoOptimize()) doesn't
 		/// change the index order of documents.
 		/// </summary>
 		[Test]
@@ -62,10 +62,11 @@ namespace Lucene.Net.Index
 			
 			Directory merged = new MockRAMDirectory();
 			
-			IndexWriter writer = new IndexWriter(merged, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
+			IndexWriter writer = new IndexWriter(merged, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMergeFactor(2);
 			
-			writer.AddIndexes(new Directory[]{indexA, indexB});
+			writer.AddIndexesNoOptimize(new []{indexA, indexB});
+            writer.Optimize();
 			writer.Close();
 			
 			fail = VerifyIndex(merged, 0);
@@ -77,7 +78,7 @@ namespace Lucene.Net.Index
 		private bool VerifyIndex(Directory directory, int startAt)
 		{
 			bool fail = false;
-			IndexReader reader = IndexReader.Open(directory);
+			IndexReader reader = IndexReader.Open(directory, true);
 			
 			int max = reader.MaxDoc();
 			for (int i = 0; i < max; i++)
@@ -98,7 +99,7 @@ namespace Lucene.Net.Index
 		private void  FillIndex(Directory dir, int start, int numDocs)
 		{
 			
-			IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
+			IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMergeFactor(2);
 			writer.SetMaxBufferedDocs(2);
 			

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriterReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriterReader.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriterReader.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriterReader.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using NUnit.Framework;
 
 using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
@@ -40,7 +40,7 @@ namespace Lucene.Net.Index
     [TestFixture]
 	public class TestIndexWriterReader:LuceneTestCase
 	{
-		private class AnonymousClassThread:SupportClass.ThreadClass
+		private class AnonymousClassThread:ThreadClass
 		{
 			public AnonymousClassThread(long endTime, Lucene.Net.Index.IndexWriter writer, Lucene.Net.Store.Directory[] dirs, System.Collections.IList excs, TestIndexWriterReader enclosingInstance)
 			{
@@ -83,7 +83,7 @@ namespace Lucene.Net.Index
 				}
 			}
 		}
-		private class AnonymousClassThread1:SupportClass.ThreadClass
+		private class AnonymousClassThread1:ThreadClass
 		{
 			public AnonymousClassThread1(long endTime, Lucene.Net.Index.IndexWriter writer, System.Collections.IList excs, TestIndexWriterReader enclosingInstance)
 			{
@@ -216,8 +216,8 @@ namespace Lucene.Net.Index
 			r1.Close();
 			writer.Close();
 			Assert.IsTrue(r2.IsCurrent());
-			
-			IndexReader r3 = IndexReader.Open(dir1);
+
+		    IndexReader r3 = IndexReader.Open(dir1, true);
 			Assert.IsTrue(r3.IsCurrent());
 			Assert.IsTrue(r2.IsCurrent());
 			Assert.AreEqual(0, Count(new Term("id", id10), r3));
@@ -402,8 +402,8 @@ namespace Lucene.Net.Index
 			Assert.IsTrue(addDirThreads.failures.Count == 0);
 			
 			_TestUtil.CheckIndex(mainDir);
-			
-			IndexReader reader = IndexReader.Open(mainDir);
+
+		    IndexReader reader = IndexReader.Open(mainDir, true);
 			Assert.AreEqual(addDirThreads.count.IntValue(), reader.NumDocs());
 			//Assert.AreEqual(100 + numDirs * (3 * numIter / 4) * addDirThreads.NUM_THREADS
 			//    * addDirThreads.NUM_INIT_DOCS, reader.numDocs());
@@ -415,7 +415,7 @@ namespace Lucene.Net.Index
 		
 		private class DeleteThreads
 		{
-			private class AnonymousClassThread2:SupportClass.ThreadClass
+			private class AnonymousClassThread2:ThreadClass
 			{
 				public AnonymousClassThread2(DeleteThreads enclosingInstance)
 				{
@@ -454,7 +454,7 @@ namespace Lucene.Net.Index
 			private void  InitBlock(TestIndexWriterReader enclosingInstance)
 			{
 				this.enclosingInstance = enclosingInstance;
-				threads = new SupportClass.ThreadClass[NUM_THREADS];
+				threads = new ThreadClass[NUM_THREADS];
 			}
 			private TestIndexWriterReader enclosingInstance;
 			public TestIndexWriterReader Enclosing_Instance
@@ -466,7 +466,7 @@ namespace Lucene.Net.Index
 				
 			}
 			internal const int NUM_THREADS = 5;
-			internal SupportClass.ThreadClass[] threads;
+			internal ThreadClass[] threads;
 			internal IndexWriter mainWriter;
 			internal System.Collections.IList deletedTerms = new System.Collections.ArrayList();
 			internal System.Collections.ArrayList toDeleteTerms = new System.Collections.ArrayList();
@@ -526,14 +526,14 @@ namespace Lucene.Net.Index
 					}
 					catch (System.Threading.ThreadInterruptedException ie)
 					{
-						SupportClass.ThreadClass.Current().Interrupt();
+					    throw;
 					}
 			}
 		}
 		
 		private class AddDirectoriesThreads
 		{
-			private class AnonymousClassThread2:SupportClass.ThreadClass
+			private class AnonymousClassThread2:ThreadClass
 			{
 				public AnonymousClassThread2(int numIter, AddDirectoriesThreads enclosingInstance)
 				{
@@ -585,7 +585,7 @@ namespace Lucene.Net.Index
 			private void  InitBlock(TestIndexWriterReader enclosingInstance)
 			{
 				this.enclosingInstance = enclosingInstance;
-				threads = new SupportClass.ThreadClass[NUM_THREADS];
+				threads = new ThreadClass[NUM_THREADS];
 			}
 			private TestIndexWriterReader enclosingInstance;
 			public TestIndexWriterReader Enclosing_Instance
@@ -600,7 +600,7 @@ namespace Lucene.Net.Index
 			internal const int NUM_THREADS = 5;
 			internal const int NUM_INIT_DOCS = 100;
 			internal int numDirs;
-			internal SupportClass.ThreadClass[] threads;
+			internal ThreadClass[] threads;
 			internal IndexWriter mainWriter;
 			internal System.Collections.IList failures = new System.Collections.ArrayList();
 			internal IndexReader[] readers;
@@ -626,7 +626,7 @@ namespace Lucene.Net.Index
 				
 				readers = new IndexReader[numDirs];
 				for (int i = 0; i < numDirs; i++)
-					readers[i] = IndexReader.Open(addDir);
+				    readers[i] = IndexReader.Open(addDir, false);
 			}
 			
 			internal virtual void  JoinThreads()
@@ -638,7 +638,7 @@ namespace Lucene.Net.Index
 					}
 					catch (System.Threading.ThreadInterruptedException ie)
 					{
-						SupportClass.ThreadClass.Current().Interrupt();
+					    throw;
 					}
 			}
 			
@@ -680,7 +680,8 @@ namespace Lucene.Net.Index
 				{
 					
 					case 0: 
-						mainWriter.AddIndexes(dirs);
+						mainWriter.AddIndexesNoOptimize(dirs);
+                        mainWriter.Optimize();
 						break;
 					
 					case 1: 
@@ -968,7 +969,7 @@ namespace Lucene.Net.Index
 			long endTime = (long) ((DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + 1000.0 * SECONDS);
 			System.Collections.IList excs = (System.Collections.IList) System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(new System.Collections.ArrayList()));
 			
-			SupportClass.ThreadClass[] threads = new SupportClass.ThreadClass[NUM_THREAD];
+			ThreadClass[] threads = new ThreadClass[NUM_THREAD];
 			for (int i = 0; i < NUM_THREAD; i++)
 			{
 				threads[i] = new AnonymousClassThread(endTime, writer, dirs, excs, this);
@@ -1047,7 +1048,7 @@ namespace Lucene.Net.Index
             long endTime = (long)((DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + 1000.0 * SECONDS);
             System.Collections.IList excs = (System.Collections.IList)System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(new System.Collections.ArrayList()));
 
-            SupportClass.ThreadClass[] threads = new SupportClass.ThreadClass[NUM_THREAD];
+            ThreadClass[] threads = new ThreadClass[NUM_THREAD];
             for (int i = 0; i < NUM_THREAD; i++)
             {
                 threads[i] = new AnonymousClassThread(endTime, writer, dirs, excs, this);
@@ -1103,7 +1104,7 @@ namespace Lucene.Net.Index
 			long endTime = (long) ((DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + 1000.0 * SECONDS);
 			System.Collections.IList excs = (System.Collections.IList) System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(new System.Collections.ArrayList()));
 			
-			SupportClass.ThreadClass[] threads = new SupportClass.ThreadClass[NUM_THREAD];
+			ThreadClass[] threads = new ThreadClass[NUM_THREAD];
 			for (int i = 0; i < NUM_THREAD; i++)
 			{
 				threads[i] = new AnonymousClassThread1(endTime, writer, excs, this);
@@ -1157,7 +1158,7 @@ namespace Lucene.Net.Index
 			w.ExpungeDeletes();
 			w.Close();
 			r.Close();
-			r = IndexReader.Open(dir);
+			r = IndexReader.Open(dir, true);
 			Assert.AreEqual(1, r.NumDocs());
 			Assert.IsFalse(r.HasDeletions());
 			r.Close();

Modified: incubator/lucene.net/trunk/test/core/Index/TestLazyBug.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestLazyBug.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestLazyBug.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestLazyBug.cs Tue Feb 28 22:43:08 2012
@@ -96,13 +96,13 @@ namespace Lucene.Net.Index
                     dataset.Add(data[i], data[i]);
 
 			Directory dir = MakeIndex();
-			IndexReader reader = IndexReader.Open(dir);
+		    IndexReader reader = IndexReader.Open(dir, true);
 			for (int i = 0; i < docs.Length; i++)
 			{
 				Document d = reader.Document(docs[i], SELECTOR);
 				d.Get(MAGIC_FIELD);
 				
-				System.Collections.IList fields = d.GetFields();
+				var fields = d.GetFields();
 				for (System.Collections.IEnumerator fi = fields.GetEnumerator(); fi.MoveNext(); )
 				{
 					Fieldable f = null;

Modified: incubator/lucene.net/trunk/test/core/Index/TestLazyProxSkipping.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestLazyProxSkipping.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestLazyProxSkipping.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestLazyProxSkipping.cs Tue Feb 28 22:43:08 2012
@@ -164,7 +164,7 @@ namespace Lucene.Net.Index
 			}
 			
 			writer.Close();
-			IndexReader reader = IndexReader.Open(directory);
+		    IndexReader reader = IndexReader.Open(directory, true);
 			TermPositions tp = reader.TermPositions();
 			tp.Seek(new Term(this.field, "b"));
 			for (int i = 0; i < 10; i++)
@@ -201,6 +201,7 @@ namespace Lucene.Net.Index
 				
 			}
 			private IndexInput input;
+		    private bool isDisposed;
 			
 			
 			internal SeeksCountingStream(TestLazyProxSkipping enclosingInstance, IndexInput input)
@@ -218,11 +219,17 @@ namespace Lucene.Net.Index
 			{
 				this.input.ReadBytes(b, offset, len);
 			}
-			
-			public override void  Close()
-			{
-				this.input.Close();
-			}
+
+            protected override void Dispose(bool disposing)
+            {
+                if (isDisposed) return;
+
+                if (disposing)
+                {
+                    this.input.Close();
+                }
+                isDisposed = true;
+            }
 			
 			public override long GetFilePointer()
 			{

Modified: incubator/lucene.net/trunk/test/core/Index/TestMultiLevelSkipList.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestMultiLevelSkipList.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestMultiLevelSkipList.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestMultiLevelSkipList.cs Tue Feb 28 22:43:08 2012
@@ -57,7 +57,7 @@ namespace Lucene.Net.Index
 				d1.Add(new Field(term.Field(), term.Text(), Field.Store.NO, Field.Index.ANALYZED));
 				writer.AddDocument(d1);
 			}
-			writer.Flush();
+			writer.Commit();
 			writer.Optimize();
 			writer.Close();
 			
@@ -112,7 +112,7 @@ namespace Lucene.Net.Index
 			
 			protected internal PayloadFilter(TokenStream input):base(input)
 			{
-				payloadAtt = (PayloadAttribute) AddAttribute(typeof(PayloadAttribute));
+				payloadAtt =  AddAttribute<PayloadAttribute>();
 			}
 			
 			public override bool IncrementToken()
@@ -146,6 +146,7 @@ namespace Lucene.Net.Index
 				
 			}
 			private IndexInput input;
+		    private bool isDisposed;
 			
 			internal CountingStream(TestMultiLevelSkipList enclosingInstance, IndexInput input)
 			{
@@ -164,11 +165,17 @@ namespace Lucene.Net.Index
 				Enclosing_Instance.counter += len;
 				this.input.ReadBytes(b, offset, len);
 			}
-			
-			public override void  Close()
-			{
-				this.input.Close();
-			}
+
+            protected override void Dispose(bool disposing)
+            {
+                if (isDisposed) return;
+
+                if (disposing)
+                {
+                    this.input.Close();
+                }
+                isDisposed = true;
+            }
 			
 			public override long GetFilePointer()
 			{

Modified: incubator/lucene.net/trunk/test/core/Index/TestMultiReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestMultiReader.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestMultiReader.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestMultiReader.cs Tue Feb 28 22:43:08 2012
@@ -38,8 +38,8 @@ namespace Lucene.Net.Index
 			IndexReader reader;
 			
 			sis.Read(dir);
-			SegmentReader reader1 = SegmentReader.Get(sis.Info(0));
-			SegmentReader reader2 = SegmentReader.Get(sis.Info(1));
+			SegmentReader reader1 = SegmentReader.Get(false, sis.Info(0), IndexReader.DEFAULT_TERMS_INDEX_DIVISOR);
+            SegmentReader reader2 = SegmentReader.Get(false, sis.Info(1), IndexReader.DEFAULT_TERMS_INDEX_DIVISOR);
 			readers[0] = reader1;
 			readers[1] = reader2;
 			Assert.IsTrue(reader1 != null);

Modified: incubator/lucene.net/trunk/test/core/Index/TestNRTReaderWithThreads.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestNRTReaderWithThreads.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestNRTReaderWithThreads.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestNRTReaderWithThreads.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using NUnit.Framework;
 
 using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
@@ -77,7 +77,7 @@ namespace Lucene.Net.Index
 			mainDir.Close();
 		}
 		
-		public class RunThread:SupportClass.ThreadClass
+		public class RunThread:ThreadClass
 		{
 			private void  InitBlock(TestNRTReaderWithThreads enclosingInstance)
 			{

Modified: incubator/lucene.net/trunk/test/core/Index/TestNorms.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestNorms.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestNorms.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestNorms.cs Tue Feb 28 22:43:08 2012
@@ -88,7 +88,7 @@ namespace Lucene.Net.Index
 		{
 			base.SetUp();
 			similarityOne = new SimilarityOne(this);
-			anlzr = new StandardAnalyzer();
+			anlzr = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 		}
 		
 		/// <summary> Test that norms values are preserved as the index is maintained.
@@ -107,7 +107,7 @@ namespace Lucene.Net.Index
 			}
 			
 			// test with a single index: index1
-			System.IO.FileInfo indexDir1 = new System.IO.FileInfo(System.IO.Path.Combine(tempDir, "lucenetestindex1"));
+			System.IO.DirectoryInfo indexDir1 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex1"));
 			Directory dir1 = FSDirectory.Open(indexDir1);
 			
 			norms = new System.Collections.ArrayList();
@@ -125,21 +125,22 @@ namespace Lucene.Net.Index
 			modifiedNorms = new System.Collections.ArrayList();
 			numDocNorms = 0;
 			
-			System.IO.FileInfo indexDir2 = new System.IO.FileInfo(System.IO.Path.Combine(tempDir, "lucenetestindex2"));
+			System.IO.DirectoryInfo indexDir2 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex2"));
 			Directory dir2 = FSDirectory.Open(indexDir2);
 			
 			CreateIndex(dir2);
 			DoTestNorms(dir2);
 			
 			// add index1 and index2 to a third index: index3
-			System.IO.FileInfo indexDir3 = new System.IO.FileInfo(System.IO.Path.Combine(tempDir, "lucenetestindex3"));
+			System.IO.DirectoryInfo indexDir3 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex3"));
 			Directory dir3 = FSDirectory.Open(indexDir3);
 			
 			CreateIndex(dir3);
 			IndexWriter iw = new IndexWriter(dir3, anlzr, false, IndexWriter.MaxFieldLength.LIMITED);
 			iw.SetMaxBufferedDocs(5);
 			iw.SetMergeFactor(3);
-			iw.AddIndexes(new Directory[]{dir1, dir2});
+			iw.AddIndexesNoOptimize(new Directory[]{dir1, dir2});
+            iw.Optimize();
 			iw.Close();
 			
 			norms1.AddRange(norms);
@@ -192,18 +193,18 @@ namespace Lucene.Net.Index
 		
 		private void  ModifyNormsForF1(Directory dir)
 		{
-			IndexReader ir = IndexReader.Open(dir);
+			IndexReader ir = IndexReader.Open(dir, false);
 			int n = ir.MaxDoc();
 			for (int i = 0; i < n; i += 3)
 			{
 				// modify for every third doc
 				int k = (i * 3) % modifiedNorms.Count;
-				float origNorm = (float) ((System.Single) modifiedNorms[i]);
-				float newNorm = (float) ((System.Single) modifiedNorms[k]);
+				float origNorm = (float)modifiedNorms[i];
+                float newNorm = (float)modifiedNorms[k];
 				//System.out.println("Modifying: for "+i+" from "+origNorm+" to "+newNorm);
 				//System.out.println("      and: for "+k+" from "+newNorm+" to "+origNorm);
-				modifiedNorms[i] = (float) newNorm;
-				modifiedNorms[k] = (float) origNorm;
+				modifiedNorms[i] = newNorm;
+				modifiedNorms[k] = origNorm;
 				ir.SetNorm(i, "f" + 1, newNorm);
 				ir.SetNorm(k, "f" + 1, origNorm);
 			}
@@ -213,7 +214,7 @@ namespace Lucene.Net.Index
 		
 		private void  VerifyIndex(Directory dir)
 		{
-			IndexReader ir = IndexReader.Open(dir);
+		    IndexReader ir = IndexReader.Open(dir, false);
 			for (int i = 0; i < NUM_FIELDS; i++)
 			{
 				System.String field = "f" + i;
@@ -223,7 +224,7 @@ namespace Lucene.Net.Index
 				for (int j = 0; j < b.Length; j++)
 				{
 					float norm = Similarity.DecodeNorm(b[j]);
-					float norm1 = (float) ((System.Single) storedNorms[j]);
+					float norm1 = (float)storedNorms[j];
 					Assert.AreEqual(norm, norm1, 0.000001, "stored norm value of " + field + " for doc " + j + " is " + norm + " - a mismatch!");
 				}
 			}
@@ -273,8 +274,8 @@ namespace Lucene.Net.Index
 				norm += normDelta;
 			}
 			while (true);
-			norms.Insert(numDocNorms, (float) norm);
-			modifiedNorms.Insert(numDocNorms, (float) norm);
+			norms.Insert(numDocNorms, norm);
+			modifiedNorms.Insert(numDocNorms, norm);
 			//System.out.println("creating norm("+numDocNorms+"): "+norm);
 			numDocNorms++;
 			lastNorm = (norm > 10?0:norm); //there's a limit to how many distinct values can be stored in a ingle byte

Modified: incubator/lucene.net/trunk/test/core/Index/TestOmitTf.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestOmitTf.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestOmitTf.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestOmitTf.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Search;
 using NUnit.Framework;
 
 using Analyzer = Lucene.Net.Analysis.Analyzer;
@@ -38,8 +38,6 @@ using _TestUtil = Lucene.Net.Util._TestU
 
 namespace Lucene.Net.Index
 {
-	
-	
     [TestFixture]
 	public class TestOmitTf:LuceneTestCase
 	{
@@ -203,6 +201,19 @@ namespace Lucene.Net.Index
 			}
 		}
 		
+        private class AnonymousIDFExplanation : Explanation.IDFExplanation
+        {
+            public override float GetIdf()
+            {
+                return 1.0f;
+            }
+
+            public override string Explain()
+            {
+                return "Inexplicable";
+            }
+        }
+
 		[Serializable]
 		public class SimpleSimilarity:Similarity
 		{
@@ -224,10 +235,6 @@ namespace Lucene.Net.Index
 			{
 				return 2.0f;
 			}
-			public override float Idf(System.Collections.ICollection terms, Searcher searcher)
-			{
-				return 1.0f;
-			}
 			public override float Idf(int docFreq, int numDocs)
 			{
 				return 1.0f;
@@ -236,6 +243,10 @@ namespace Lucene.Net.Index
 			{
 				return 1.0f;
 			}
+            public override Search.Explanation.IDFExplanation IdfExplain(System.Collections.Generic.ICollection<Term> terms, Searcher searcher)
+            {
+                return new AnonymousIDFExplanation();
+            }
 		}
 		
 		
@@ -244,7 +255,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestOmitTermFreqAndPositions()
 		{
 			Directory ram = new MockRAMDirectory();
-			Analyzer analyzer = new StandardAnalyzer();
+			Analyzer analyzer = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 			IndexWriter writer = new IndexWriter(ram, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			Document d = new Document();
 			
@@ -292,7 +303,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestMixedMerge()
 		{
 			Directory ram = new MockRAMDirectory();
-			Analyzer analyzer = new StandardAnalyzer();
+			Analyzer analyzer = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 			IndexWriter writer = new IndexWriter(ram, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMaxBufferedDocs(3);
 			writer.SetMergeFactor(2);
@@ -347,7 +358,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestMixedRAM()
 		{
 			Directory ram = new MockRAMDirectory();
-			Analyzer analyzer = new StandardAnalyzer();
+			Analyzer analyzer = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 			IndexWriter writer = new IndexWriter(ram, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMaxBufferedDocs(10);
 			writer.SetMergeFactor(2);
@@ -398,7 +409,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestNoPrxFile()
 		{
 			Directory ram = new MockRAMDirectory();
-			Analyzer analyzer = new StandardAnalyzer();
+			Analyzer analyzer = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 			IndexWriter writer = new IndexWriter(ram, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMaxBufferedDocs(3);
 			writer.SetMergeFactor(2);
@@ -431,7 +442,7 @@ namespace Lucene.Net.Index
 		public virtual void  TestBasic()
 		{
 			Directory dir = new MockRAMDirectory();
-			Analyzer analyzer = new StandardAnalyzer();
+			Analyzer analyzer = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
 			IndexWriter writer = new IndexWriter(dir, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			writer.SetMergeFactor(2);
 			writer.SetMaxBufferedDocs(2);
@@ -464,7 +475,7 @@ namespace Lucene.Net.Index
 			/*
 			* Verify the index
 			*/
-			Searcher searcher = new IndexSearcher(dir);
+			Searcher searcher = new IndexSearcher(dir, true);
 			searcher.SetSimilarity(new SimpleSimilarity());
 			
 			Term a = new Term("noTf", term);