lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject svn commit: r1299911 [10/14] - in /incubator/lucene.net/trunk: src/core/ src/core/Analysis/ src/core/Analysis/Standard/ src/core/Analysis/Tokenattributes/ src/core/Document/ src/core/Index/ src/core/Messages/ src/core/QueryParser/ src/core/Search/ src/...
Date Mon, 12 Mar 2012 22:29:37 GMT
Modified: incubator/lucene.net/trunk/test/core/Index/TestFieldsReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestFieldsReader.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestFieldsReader.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestFieldsReader.cs Mon Mar 12 22:29:26 2012
@@ -90,7 +90,7 @@ namespace Lucene.Net.Index
 			DocHelper.SetupDoc(testDoc);
 			fieldInfos.Add(testDoc);
 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
-			writer.SetUseCompoundFile(false);
+			writer.UseCompoundFile = false;
 			writer.AddDocument(testDoc);
 			writer.Close();
 		}
@@ -115,30 +115,30 @@ namespace Lucene.Net.Index
 			Assert.IsTrue(doc != null);
 			Assert.IsTrue(doc.GetField(DocHelper.TEXT_FIELD_1_KEY) != null);
 			
-			Fieldable field = doc.GetField(DocHelper.TEXT_FIELD_2_KEY);
+			IFieldable field = doc.GetField(DocHelper.TEXT_FIELD_2_KEY);
 			Assert.IsTrue(field != null);
-			Assert.IsTrue(field.IsTermVectorStored() == true);
+			Assert.IsTrue(field.IsTermVectorStored == true);
 			
-			Assert.IsTrue(field.IsStoreOffsetWithTermVector() == true);
-			Assert.IsTrue(field.IsStorePositionWithTermVector() == true);
-			Assert.IsTrue(field.GetOmitNorms() == false);
-			Assert.IsTrue(field.GetOmitTermFreqAndPositions() == false);
+			Assert.IsTrue(field.IsStoreOffsetWithTermVector == true);
+			Assert.IsTrue(field.IsStorePositionWithTermVector == true);
+			Assert.IsTrue(field.OmitNorms == false);
+			Assert.IsTrue(field.OmitTermFreqAndPositions == false);
 			
 			field = doc.GetField(DocHelper.TEXT_FIELD_3_KEY);
 			Assert.IsTrue(field != null);
-			Assert.IsTrue(field.IsTermVectorStored() == false);
-			Assert.IsTrue(field.IsStoreOffsetWithTermVector() == false);
-			Assert.IsTrue(field.IsStorePositionWithTermVector() == false);
-			Assert.IsTrue(field.GetOmitNorms() == true);
-			Assert.IsTrue(field.GetOmitTermFreqAndPositions() == false);
+			Assert.IsTrue(field.IsTermVectorStored == false);
+			Assert.IsTrue(field.IsStoreOffsetWithTermVector == false);
+			Assert.IsTrue(field.IsStorePositionWithTermVector == false);
+			Assert.IsTrue(field.OmitNorms == true);
+			Assert.IsTrue(field.OmitTermFreqAndPositions == false);
 			
 			field = doc.GetField(DocHelper.NO_TF_KEY);
 			Assert.IsTrue(field != null);
-			Assert.IsTrue(field.IsTermVectorStored() == false);
-			Assert.IsTrue(field.IsStoreOffsetWithTermVector() == false);
-			Assert.IsTrue(field.IsStorePositionWithTermVector() == false);
-			Assert.IsTrue(field.GetOmitNorms() == false);
-			Assert.IsTrue(field.GetOmitTermFreqAndPositions() == true);
+			Assert.IsTrue(field.IsTermVectorStored == false);
+			Assert.IsTrue(field.IsStoreOffsetWithTermVector == false);
+			Assert.IsTrue(field.IsStorePositionWithTermVector == false);
+			Assert.IsTrue(field.OmitNorms == false);
+			Assert.IsTrue(field.OmitTermFreqAndPositions == true);
 			reader.Dispose();
 		}
 		
@@ -163,30 +163,30 @@ namespace Lucene.Net.Index
 			SetBasedFieldSelector fieldSelector = new SetBasedFieldSelector(loadFieldNames, lazyFieldNames);
 			Document doc = reader.Doc(0, fieldSelector);
 			Assert.IsTrue(doc != null, "doc is null and it shouldn't be");
-			Fieldable field = doc.GetFieldable(DocHelper.LAZY_FIELD_KEY);
+			IFieldable field = doc.GetFieldable(DocHelper.LAZY_FIELD_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.IsLazy(), "field is not lazy and it should be");
-			System.String value_Renamed = field.StringValue();
+			Assert.IsTrue(field.IsLazy, "field is not lazy and it should be");
+			System.String value_Renamed = field.StringValue;
 			Assert.IsTrue(value_Renamed != null, "value is null and it shouldn't be");
 			Assert.IsTrue(value_Renamed.Equals(DocHelper.LAZY_FIELD_TEXT) == true, value_Renamed + " is not equal to " + DocHelper.LAZY_FIELD_TEXT);
 			field = doc.GetFieldable(DocHelper.TEXT_FIELD_1_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.IsLazy() == false, "Field is lazy and it should not be");
+			Assert.IsTrue(field.IsLazy == false, "Field is lazy and it should not be");
 			field = doc.GetFieldable(DocHelper.TEXT_FIELD_UTF1_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.IsLazy() == false, "Field is lazy and it should not be");
-			Assert.IsTrue(field.StringValue().Equals(DocHelper.FIELD_UTF1_TEXT) == true, field.StringValue() + " is not equal to " + DocHelper.FIELD_UTF1_TEXT);
+			Assert.IsTrue(field.IsLazy == false, "Field is lazy and it should not be");
+			Assert.IsTrue(field.StringValue.Equals(DocHelper.FIELD_UTF1_TEXT) == true, field.StringValue + " is not equal to " + DocHelper.FIELD_UTF1_TEXT);
 			
 			field = doc.GetFieldable(DocHelper.TEXT_FIELD_UTF2_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.IsLazy() == true, "Field is lazy and it should not be");
-			Assert.IsTrue(field.StringValue().Equals(DocHelper.FIELD_UTF2_TEXT) == true, field.StringValue() + " is not equal to " + DocHelper.FIELD_UTF2_TEXT);
+			Assert.IsTrue(field.IsLazy == true, "Field is lazy and it should not be");
+			Assert.IsTrue(field.StringValue.Equals(DocHelper.FIELD_UTF2_TEXT) == true, field.StringValue + " is not equal to " + DocHelper.FIELD_UTF2_TEXT);
 			
 			field = doc.GetFieldable(DocHelper.LAZY_FIELD_BINARY_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.StringValue() == null, "stringValue isn't null for lazy binary field");
+			Assert.IsTrue(field.StringValue == null, "stringValue isn't null for lazy binary field");
 			
-			byte[] bytes = field.GetBinaryValue();
+			byte[] bytes = field.BinaryValue;
 			Assert.IsTrue(bytes != null, "bytes is null and it shouldn't be");
 			Assert.IsTrue(DocHelper.LAZY_FIELD_BINARY_BYTES.Length == bytes.Length, "");
 			for (int i = 0; i < bytes.Length; i++)
@@ -214,13 +214,13 @@ namespace Lucene.Net.Index
 			SetBasedFieldSelector fieldSelector = new SetBasedFieldSelector(loadFieldNames, lazyFieldNames);
 			Document doc = reader.Doc(0, fieldSelector);
 			Assert.IsTrue(doc != null, "doc is null and it shouldn't be");
-			Fieldable field = doc.GetFieldable(DocHelper.LAZY_FIELD_KEY);
+			IFieldable field = doc.GetFieldable(DocHelper.LAZY_FIELD_KEY);
 			Assert.IsTrue(field != null, "field is null and it shouldn't be");
-			Assert.IsTrue(field.IsLazy(), "field is not lazy and it should be");
+			Assert.IsTrue(field.IsLazy, "field is not lazy and it should be");
             reader.Dispose();
 			try
 			{
-				field.StringValue();
+				var value = field.StringValue;
 				Assert.Fail("did not hit AlreadyClosedException as expected");
 			}
 			catch (AlreadyClosedException e)
@@ -246,7 +246,7 @@ namespace Lucene.Net.Index
 			{
 				Field field = (Field) iter.Current;
 				Assert.IsTrue(field != null, "field is null and it shouldn't be");
-				System.String sv = field.StringValue();
+				System.String sv = field.StringValue;
 				Assert.IsTrue(sv != null, "sv is null and it shouldn't be");
 				count++;
 			}
@@ -271,7 +271,7 @@ namespace Lucene.Net.Index
 			Assert.IsTrue(tmpDir != null);
 			
 			IndexWriter writer = new IndexWriter(tmpDir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
-			writer.SetUseCompoundFile(false);
+			writer.UseCompoundFile = false;
 			writer.AddDocument(testDoc);
 			writer.Close();
 			
@@ -293,14 +293,14 @@ namespace Lucene.Net.Index
 				Document doc;
 				doc = reader.Doc(0, null); //Load all of them
 				Assert.IsTrue(doc != null, "doc is null and it shouldn't be");
-				Fieldable field = doc.GetFieldable(DocHelper.LARGE_LAZY_FIELD_KEY);
-				Assert.IsTrue(field.IsLazy() == false, "field is lazy");
+				IFieldable field = doc.GetFieldable(DocHelper.LARGE_LAZY_FIELD_KEY);
+				Assert.IsTrue(field.IsLazy == false, "field is lazy");
 				System.String value_Renamed;
 				long start;
 				long finish;
 				start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
 				//On my machine this was always 0ms.
-				value_Renamed = field.StringValue();
+				value_Renamed = field.StringValue;
 				finish = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
 				Assert.IsTrue(value_Renamed != null, "value is null and it shouldn't be");
 				Assert.IsTrue(field != null, "field is null and it shouldn't be");
@@ -313,10 +313,10 @@ namespace Lucene.Net.Index
 				reader = new FieldsReader(tmpDir, TEST_SEGMENT_NAME, fieldInfos);
 				doc = reader.Doc(0, fieldSelector);
 				field = doc.GetFieldable(DocHelper.LARGE_LAZY_FIELD_KEY);
-				Assert.IsTrue(field.IsLazy() == true, "field is not lazy");
+				Assert.IsTrue(field.IsLazy == true, "field is not lazy");
 				start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
 				//On my machine this took around 50 - 70ms
-				value_Renamed = field.StringValue();
+				value_Renamed = field.StringValue;
 				finish = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
 				Assert.IsTrue(value_Renamed != null, "value is null and it shouldn't be");
 				lazyTime += (finish - start);
@@ -333,15 +333,15 @@ namespace Lucene.Net.Index
 			Document doc;
 			
 			doc = reader.Doc(0, new AnonymousClassFieldSelector(this));
-			Fieldable f1 = doc.GetFieldable(DocHelper.TEXT_FIELD_1_KEY);
-			Fieldable f3 = doc.GetFieldable(DocHelper.TEXT_FIELD_3_KEY);
-			Fieldable fb = doc.GetFieldable(DocHelper.LAZY_FIELD_BINARY_KEY);
-			Assert.IsTrue(f1.IsBinary());
-			Assert.IsTrue(!f3.IsBinary());
-			Assert.IsTrue(fb.IsBinary());
-			AssertSizeEquals(2 * DocHelper.FIELD_1_TEXT.Length, f1.GetBinaryValue());
-			Assert.AreEqual(DocHelper.FIELD_3_TEXT, f3.StringValue());
-            AssertSizeEquals(DocHelper.LAZY_FIELD_BINARY_BYTES.Length, fb.GetBinaryValue());
+			IFieldable f1 = doc.GetFieldable(DocHelper.TEXT_FIELD_1_KEY);
+			IFieldable f3 = doc.GetFieldable(DocHelper.TEXT_FIELD_3_KEY);
+			IFieldable fb = doc.GetFieldable(DocHelper.LAZY_FIELD_BINARY_KEY);
+			Assert.IsTrue(f1.IsBinary);
+			Assert.IsTrue(!f3.IsBinary);
+			Assert.IsTrue(fb.IsBinary);
+			AssertSizeEquals(2 * DocHelper.FIELD_1_TEXT.Length, f1.BinaryValue);
+			Assert.AreEqual(DocHelper.FIELD_3_TEXT, f3.StringValue);
+            AssertSizeEquals(DocHelper.LAZY_FIELD_BINARY_BYTES.Length, fb.BinaryValue);
 
             reader.Dispose();
 		}
@@ -361,7 +361,7 @@ namespace Lucene.Net.Index
 			public FaultyFSDirectory(System.IO.DirectoryInfo dir)
 			{
 				fsDir = FSDirectory.Open(dir);
-				lockFactory = fsDir.GetLockFactory();
+				lockFactory = fsDir.LockFactory;
 			}
 			public override IndexInput OpenInput(System.String name)
 			{

Modified: incubator/lucene.net/trunk/test/core/Index/TestFilterIndexReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestFilterIndexReader.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestFilterIndexReader.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestFilterIndexReader.cs Mon Mar 12 22:29:26 2012
@@ -123,7 +123,7 @@ namespace Lucene.Net.Index
 			
 			IndexReader reader = new TestReader(IndexReader.Open(directory, true));
 			
-			Assert.IsTrue(reader.IsOptimized());
+			Assert.IsTrue(reader.IsOptimized);
 			
 			TermEnum terms = reader.Terms();
 			while (terms.Next())

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexCommit.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexCommit.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexCommit.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexCommit.cs Mon Mar 12 22:29:26 2012
@@ -22,22 +22,22 @@ namespace Lucene.Net.Index
                 _dir = dir;
             }
 
-            public override string GetSegmentsFileName()
+            public override string SegmentsFileName
             {
-                return "a";
+                get { return "a"; }
             }
 
-            public override ICollection<string> GetFileNames()
+            public override ICollection<string> FileNames
             {
-                return null;
+                get { return null; }
             }
 
             public override void Delete()
             { }
 
-            public override bool IsDeleted()
+            public override bool IsDeleted
             {
-                return false;
+                get { return false; }
             }
 
             public override bool IsOptimized()
@@ -45,29 +45,29 @@ namespace Lucene.Net.Index
                 return false;
             }
 
-            public override long GetVersion()
+            public override long Version
             {
-                return 12;
+                get { return 12; }
             }
 
-            public override long GetGeneration()
+            public override long Generation
             {
-                return 0;
+                get { return 0; }
             }
 
-            public override IDictionary<string, string> GetUserData()
+            public override IDictionary<string, string> UserData
             {
-                return null;
+                get { return null; }
             }
 
-            public override Directory GetDirectory()
+            public override Directory Directory
             {
-                return _dir;
+                get { return _dir; }
             }
 
-            public override long GetTimestamp()
+            public override long Timestamp
             {
-                return 1;
+                get { return 1; }
             }
         }
         private class IndexCommitSecond : IndexCommit
@@ -79,22 +79,22 @@ namespace Lucene.Net.Index
                 _dir = dir;
             }
 
-            public override string GetSegmentsFileName()
+            public override string SegmentsFileName
             {
-                return "b";
+                get { return "b"; }
             }
 
-            public override ICollection<string> GetFileNames()
+            public override ICollection<string> FileNames
             {
-                return null;
+                get { return null; }
             }
 
             public override void Delete()
             { }
 
-            public override bool IsDeleted()
+            public override bool IsDeleted
             {
-                return false;
+                get { return false; }
             }
 
             public override bool IsOptimized()
@@ -102,29 +102,29 @@ namespace Lucene.Net.Index
                 return false;
             }
 
-            public override long GetVersion()
+            public override long Version
             {
-                return 12;
+                get { return 12; }
             }
 
-            public override long GetGeneration()
+            public override long Generation
             {
-                return 0;
+                get { return 0; }
             }
 
-            public override IDictionary<string, string> GetUserData()
+            public override IDictionary<string, string> UserData
             {
-                return null;
+                get { return null; }
             }
 
-            public override Directory GetDirectory()
+            public override Directory Directory
             {
-                return _dir;
+                get { return _dir; }
             }
 
-            public override long GetTimestamp()
+            public override long Timestamp
             {
-                return 1;
+                get { return 1; }
             }
         }
 

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexFileDeleter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexFileDeleter.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexFileDeleter.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexFileDeleter.cs Mon Mar 12 22:29:26 2012
@@ -51,7 +51,7 @@ namespace Lucene.Net.Index
 			{
 				AddDoc(writer, i);
 			}
-			writer.SetUseCompoundFile(false);
+			writer.UseCompoundFile = false;
 			for (; i < 45; i++)
 			{
 				AddDoc(writer, i);

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexReader.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexReader.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexReader.cs Mon Mar 12 22:29:26 2012
@@ -17,6 +17,7 @@
 
 using System;
 using System.Collections.Generic;
+using Lucene.Net.Documents;
 using Lucene.Net.Support;
 using NUnit.Framework;
 
@@ -25,7 +26,6 @@ using StandardAnalyzer = Lucene.Net.Anal
 using Document = Lucene.Net.Documents.Document;
 using Field = Lucene.Net.Documents.Field;
 using FieldSelector = Lucene.Net.Documents.FieldSelector;
-using Fieldable = Lucene.Net.Documents.Fieldable;
 using SetBasedFieldSelector = Lucene.Net.Documents.SetBasedFieldSelector;
 using FieldOption = Lucene.Net.Index.IndexReader.FieldOption;
 using AlreadyClosedException = Lucene.Net.Store.AlreadyClosedException;
@@ -90,12 +90,12 @@ namespace Lucene.Net.Index
 			SegmentInfos sis = new SegmentInfos();
 			sis.Read(d);
 			IndexReader r2 = IndexReader.Open(d, false);
-			IndexCommit c = r.GetIndexCommit();
-			Assert.AreEqual(c.GetUserData(), commitUserData);
+			IndexCommit c = r.IndexCommit;
+			Assert.AreEqual(c.UserData, commitUserData);
 			
-			Assert.AreEqual(sis.GetCurrentSegmentFileName(), c.GetSegmentsFileName());
+			Assert.AreEqual(sis.GetCurrentSegmentFileName(), c.SegmentsFileName);
 			
-			Assert.IsTrue(c.Equals(r.GetIndexCommit()));
+			Assert.IsTrue(c.Equals(r.IndexCommit));
 			
 			// Change the index
             writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -105,8 +105,8 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			IndexReader r3 = r2.Reopen();
-			Assert.IsFalse(c.Equals(r3.GetIndexCommit()));
-			Assert.IsFalse(r2.GetIndexCommit().IsOptimized());
+			Assert.IsFalse(c.Equals(r3.IndexCommit));
+			Assert.IsFalse(r2.IndexCommit.IsOptimized());
 			r3.Close();
 
             writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -114,7 +114,7 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			r3 = r2.Reopen();
-			Assert.IsTrue(r3.GetIndexCommit().IsOptimized());
+			Assert.IsTrue(r3.IndexCommit.IsOptimized());
 			r2.Close();
 			r3.Close();
 			d.Close();
@@ -129,17 +129,17 @@ namespace Lucene.Net.Index
 			writer.Close();
 			// set up reader:
 			IndexReader reader = IndexReader.Open(d, false);
-			Assert.IsTrue(reader.IsCurrent());
+			Assert.IsTrue(reader.IsCurrent);
 			// modify index by adding another document:
             writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
 			AddDocumentWithFields(writer);
 			writer.Close();
-			Assert.IsFalse(reader.IsCurrent());
+			Assert.IsFalse(reader.IsCurrent);
 			// re-create index:
             writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
 			AddDocumentWithFields(writer);
 			writer.Close();
-			Assert.IsFalse(reader.IsCurrent());
+			Assert.IsFalse(reader.IsCurrent);
 			reader.Close();
 			d.Close();
 		}
@@ -263,7 +263,7 @@ namespace Lucene.Net.Index
 			IndexReader reader = IndexReader.Open(d, false);
 			FieldSortedTermVectorMapper mapper = new FieldSortedTermVectorMapper(new TermVectorEntryFreqSortedComparator());
 			reader.GetTermFreqVector(0, mapper);
-			var map = mapper.GetFieldToTerms();
+			var map = mapper.FieldToTerms;
 			Assert.IsTrue(map != null, "map is null and it shouldn't be");
 			Assert.IsTrue(map.Count == 4, "map Size: " + map.Count + " is not: " + 4);
             var set_Renamed = map["termvector"];
@@ -369,33 +369,33 @@ namespace Lucene.Net.Index
 			writer.AddDocument(doc);
 			writer.Close();
 			IndexReader reader = IndexReader.Open(dir, false);
-			doc = reader.Document(reader.MaxDoc() - 1);
+			doc = reader.Document(reader.MaxDoc - 1);
 			Field[] fields = doc.GetFields("bin1");
 			Assert.IsNotNull(fields);
 			Assert.AreEqual(1, fields.Length);
 			Field b1 = fields[0];
-			Assert.IsTrue(b1.IsBinary());
-			byte[] data1 = b1.GetBinaryValue();
-			Assert.AreEqual(bin.Length, b1.GetBinaryLength());
+			Assert.IsTrue(b1.IsBinary);
+			byte[] data1 = b1.BinaryValue;
+			Assert.AreEqual(bin.Length, b1.BinaryLength);
 			for (int i = 0; i < bin.Length; i++)
 			{
-				Assert.AreEqual(bin[i], data1[i + b1.GetBinaryOffset()]);
+				Assert.AreEqual(bin[i], data1[i + b1.BinaryOffset]);
 			}
 			var lazyFields = new HashSet<string>();
 			lazyFields.Add("bin1");
 			FieldSelector sel = new SetBasedFieldSelector(new HashSet<string>(), lazyFields);
-			doc = reader.Document(reader.MaxDoc() - 1, sel);
-			Fieldable[] fieldables = doc.GetFieldables("bin1");
+			doc = reader.Document(reader.MaxDoc - 1, sel);
+			IFieldable[] fieldables = doc.GetFieldables("bin1");
 			Assert.IsNotNull(fieldables);
 			Assert.AreEqual(1, fieldables.Length);
-			Fieldable fb1 = fieldables[0];
-			Assert.IsTrue(fb1.IsBinary());
-			Assert.AreEqual(bin.Length, fb1.GetBinaryLength());
-			data1 = fb1.GetBinaryValue();
-			Assert.AreEqual(bin.Length, fb1.GetBinaryLength());
+			IFieldable fb1 = fieldables[0];
+			Assert.IsTrue(fb1.IsBinary);
+			Assert.AreEqual(bin.Length, fb1.BinaryLength);
+			data1 = fb1.BinaryValue;
+			Assert.AreEqual(bin.Length, fb1.BinaryLength);
 			for (int i = 0; i < bin.Length; i++)
 			{
-				Assert.AreEqual(bin[i], data1[i + fb1.GetBinaryOffset()]);
+				Assert.AreEqual(bin[i], data1[i + fb1.BinaryOffset]);
 			}
 			reader.Close();
 			// force optimize
@@ -405,17 +405,17 @@ namespace Lucene.Net.Index
 			writer.Optimize();
 			writer.Close();
 			reader = IndexReader.Open(dir, false);
-			doc = reader.Document(reader.MaxDoc() - 1);
+			doc = reader.Document(reader.MaxDoc - 1);
 			fields = doc.GetFields("bin1");
 			Assert.IsNotNull(fields);
 			Assert.AreEqual(1, fields.Length);
 			b1 = fields[0];
-			Assert.IsTrue(b1.IsBinary());
-			data1 = b1.GetBinaryValue();
-			Assert.AreEqual(bin.Length, b1.GetBinaryLength());
+			Assert.IsTrue(b1.IsBinary);
+			data1 = b1.BinaryValue;
+			Assert.AreEqual(bin.Length, b1.BinaryLength);
 			for (int i = 0; i < bin.Length; i++)
 			{
-				Assert.AreEqual(bin[i], data1[i + b1.GetBinaryOffset()]);
+				Assert.AreEqual(bin[i], data1[i + b1.BinaryOffset]);
 			}
 			reader.Close();
 		}
@@ -593,7 +593,7 @@ namespace Lucene.Net.Index
 			
 			//  add 1 documents with term : aaa
 			writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
-			writer.SetUseCompoundFile(false);
+			writer.UseCompoundFile = false;
 			AddDoc(writer, searchTerm.Text());
 			writer.Close();
 			
@@ -886,7 +886,7 @@ namespace Lucene.Net.Index
 			reader.UndeleteAll();
 			reader.Close();
 			reader = IndexReader.Open(dir, false);
-			Assert.AreEqual(2, reader.NumDocs()); // nothing has really been deleted thanks to undeleteAll()
+			Assert.AreEqual(2, reader.NumDocs); // nothing has really been deleted thanks to undeleteAll()
 			reader.Close();
 			dir.Close();
 		}
@@ -905,7 +905,7 @@ namespace Lucene.Net.Index
 			reader.Close();
 			reader = IndexReader.Open(dir, false);
 			reader.UndeleteAll();
-			Assert.AreEqual(2, reader.NumDocs()); // nothing has really been deleted thanks to undeleteAll()
+			Assert.AreEqual(2, reader.NumDocs); // nothing has really been deleted thanks to undeleteAll()
 			reader.Close();
 			dir.Close();
 		}
@@ -926,7 +926,7 @@ namespace Lucene.Net.Index
 			reader.UndeleteAll();
 			reader.Close();
 			reader = IndexReader.Open(dir, false);
-			Assert.AreEqual(2, reader.NumDocs()); // nothing has really been deleted thanks to undeleteAll()
+			Assert.AreEqual(2, reader.NumDocs); // nothing has really been deleted thanks to undeleteAll()
 			reader.Close();
 			dir.Close();
 		}
@@ -1511,17 +1511,17 @@ namespace Lucene.Net.Index
 		
 		public static void  AssertIndexEquals(IndexReader index1, IndexReader index2)
 		{
-			Assert.AreEqual(index1.NumDocs(), index2.NumDocs(), "IndexReaders have different values for numDocs.");
-			Assert.AreEqual(index1.MaxDoc(), index2.MaxDoc(), "IndexReaders have different values for maxDoc.");
-			Assert.AreEqual(index1.HasDeletions(), index2.HasDeletions(), "Only one IndexReader has deletions.");
-			Assert.AreEqual(index1.IsOptimized(), index2.IsOptimized(), "Only one index is optimized.");
+			Assert.AreEqual(index1.NumDocs, index2.NumDocs, "IndexReaders have different values for numDocs.");
+			Assert.AreEqual(index1.MaxDoc, index2.MaxDoc, "IndexReaders have different values for maxDoc.");
+			Assert.AreEqual(index1.HasDeletions, index2.HasDeletions, "Only one IndexReader has deletions.");
+			Assert.AreEqual(index1.IsOptimized, index2.IsOptimized, "Only one index is optimized.");
 			
 			// check field names
 			System.Collections.Generic.ICollection<string> fieldsNames1 = index1.GetFieldNames(FieldOption.ALL);
 			System.Collections.Generic.ICollection<string> fieldsNames2 = index1.GetFieldNames(FieldOption.ALL);
 
-            System.Collections.Generic.ICollection<Fieldable> fields1 = null;
-            System.Collections.Generic.ICollection<Fieldable> fields2 = null;
+            System.Collections.Generic.ICollection<IFieldable> fields1 = null;
+            System.Collections.Generic.ICollection<IFieldable> fields2 = null;
 
             Assert.AreEqual(fieldsNames1.Count, fieldsNames2.Count, "IndexReaders have different numbers of fields.");
             System.Collections.IEnumerator it1 = fieldsNames1.GetEnumerator();
@@ -1553,13 +1553,13 @@ namespace Lucene.Net.Index
 			}
 			
 			// check deletions
-			for (int i = 0; i < index1.MaxDoc(); i++)
+			for (int i = 0; i < index1.MaxDoc; i++)
 			{
 				Assert.AreEqual(index1.IsDeleted(i), index2.IsDeleted(i), "Doc " + i + " only deleted in one index.");
 			}
 			
 			// check stored fields
-			for (int i = 0; i < index1.MaxDoc(); i++)
+			for (int i = 0; i < index1.MaxDoc; i++)
 			{
 				if (!index1.IsDeleted(i))
 				{
@@ -1574,8 +1574,8 @@ namespace Lucene.Net.Index
 					{
 						Field curField1 = (Field) it1.Current;
 						Field curField2 = (Field) it2.Current;
-						Assert.AreEqual(curField1.Name(), curField2.Name(), "Different fields names for doc " + i + ".");
-						Assert.AreEqual(curField1.StringValue(), curField2.StringValue(), "Different field values for doc " + i + ".");
+						Assert.AreEqual(curField1.Name, curField2.Name, "Different fields names for doc " + i + ".");
+						Assert.AreEqual(curField1.StringValue, curField2.StringValue, "Different field values for doc " + i + ".");
 					}
 				}
 			}
@@ -1619,11 +1619,11 @@ namespace Lucene.Net.Index
 			SegmentInfos sis = new SegmentInfos();
 			sis.Read(d);
 			IndexReader r = IndexReader.Open(d, false);
-			IndexCommit c = r.GetIndexCommit();
+			IndexCommit c = r.IndexCommit;
 			
-			Assert.AreEqual(sis.GetCurrentSegmentFileName(), c.GetSegmentsFileName());
+			Assert.AreEqual(sis.GetCurrentSegmentFileName(), c.SegmentsFileName);
 			
-			Assert.IsTrue(c.Equals(r.GetIndexCommit()));
+			Assert.IsTrue(c.Equals(r.IndexCommit));
 			
 			// Change the index
 			writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -1633,8 +1633,8 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			IndexReader r2 = r.Reopen();
-			Assert.IsFalse(c.Equals(r2.GetIndexCommit()));
-			Assert.IsFalse(r2.GetIndexCommit().IsOptimized());
+			Assert.IsFalse(c.Equals(r2.IndexCommit));
+			Assert.IsFalse(r2.IndexCommit.IsOptimized());
 			r2.Close();
 			
 			writer = new IndexWriter(d, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -1642,7 +1642,7 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			r2 = r.Reopen();
-			Assert.IsTrue(r2.GetIndexCommit().IsOptimized());
+			Assert.IsTrue(r2.IndexCommit.IsOptimized());
 			
 			r.Close();
 			r2.Close();
@@ -1803,7 +1803,7 @@ namespace Lucene.Net.Index
 			while (it.MoveNext())
 			{
 				IndexCommit commit = it.Current;
-				System.Collections.Generic.ICollection<string> files = commit.GetFileNames();
+				System.Collections.Generic.ICollection<string> files = commit.FileNames;
 				System.Collections.Hashtable seen = new System.Collections.Hashtable();
 				System.Collections.IEnumerator it2 = files.GetEnumerator();
 				while (it2.MoveNext())
@@ -1876,7 +1876,7 @@ namespace Lucene.Net.Index
 			// Reopen reader1 --> reader2
 			IndexReader r2 = r.Reopen();
 			r.Close();
-			IndexReader sub0 = r2.GetSequentialSubReaders()[0];
+			IndexReader sub0 = r2.SequentialSubReaders[0];
 			int[] ints2 = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetInts(sub0, "number");
 			r2.Close();
 			Assert.IsTrue(ints == ints2);
@@ -1917,7 +1917,7 @@ namespace Lucene.Net.Index
 			IndexReader r2 = r.Reopen(true);
 			r.Close();
 			Assert.IsTrue(r2 is ReadOnlyDirectoryReader);
-			IndexReader[] subs = r2.GetSequentialSubReaders();
+			IndexReader[] subs = r2.SequentialSubReaders;
 			int[] ints2 = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetInts(subs[0], "number");
 			r2.Close();
 			
@@ -1943,24 +1943,24 @@ namespace Lucene.Net.Index
 			
 			IndexReader r = IndexReader.Open(dir, false);
 			IndexReader r1 = SegmentReader.GetOnlySegmentReader(r);
-			Assert.AreEqual(36, r1.GetUniqueTermCount());
+			Assert.AreEqual(36, r1.UniqueTermCount);
 			writer.AddDocument(doc);
 			writer.Commit();
 			IndexReader r2 = r.Reopen();
 			r.Close();
 			try
 			{
-				r2.GetUniqueTermCount();
+				var tc = r2.UniqueTermCount;
 				Assert.Fail("expected exception");
 			}
 			catch (System.NotSupportedException uoe)
 			{
 				// expected
 			}
-			IndexReader[] subs = r2.GetSequentialSubReaders();
+			IndexReader[] subs = r2.SequentialSubReaders;
 			for (int i = 0; i < subs.Length; i++)
 			{
-				Assert.AreEqual(36, subs[i].GetUniqueTermCount());
+				Assert.AreEqual(36, subs[i].UniqueTermCount);
 			}
 			r2.Close();
 			writer.Close();
@@ -1990,9 +1990,9 @@ namespace Lucene.Net.Index
 			{
 				// expected
 			}
-			Assert.IsFalse(((SegmentReader) r.GetSequentialSubReaders()[0]).TermsIndexLoaded());
+			Assert.IsFalse(((SegmentReader) r.SequentialSubReaders[0]).TermsIndexLoaded());
 
-            Assert.AreEqual(-1, (r.GetSequentialSubReaders()[0]).GetTermInfosIndexDivisor());
+            Assert.AreEqual(-1, (r.SequentialSubReaders[0]).TermInfosIndexDivisor);
 			writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
 			writer.AddDocument(doc);
 			writer.Close();
@@ -2000,7 +2000,7 @@ namespace Lucene.Net.Index
 			// LUCENE-1718: ensure re-open carries over no terms index:
 			IndexReader r2 = r.Reopen();
 			r.Close();
-			IndexReader[] subReaders = r2.GetSequentialSubReaders();
+			IndexReader[] subReaders = r2.SequentialSubReaders;
 			Assert.AreEqual(2, subReaders.Length);
 			for (int i = 0; i < 2; i++)
 			{
@@ -2019,14 +2019,14 @@ namespace Lucene.Net.Index
             Document doc = new Document();
             writer.AddDocument(doc);
             IndexReader r = IndexReader.Open(dir, true);
-            Assert.IsTrue(r.IsCurrent());
+            Assert.IsTrue(r.IsCurrent);
             writer.AddDocument(doc);
             writer.PrepareCommit();
-            Assert.IsTrue(r.IsCurrent());
+            Assert.IsTrue(r.IsCurrent);
             IndexReader r2 = r.Reopen();
             Assert.IsTrue(r == r2);
             writer.Commit();
-            Assert.IsFalse(r.IsCurrent());
+            Assert.IsFalse(r.IsCurrent);
             writer.Close();
             r.Close();
             dir.Close();

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexReaderClone.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexReaderClone.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexReaderClone.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexReaderClone.cs Mon Mar 12 22:29:26 2012
@@ -166,7 +166,7 @@ namespace Lucene.Net.Index
 				Assert.Fail("deleting from the original should not have worked");
 			}
 			// this readonly reader shouldn't have a write lock
-			if (readOnlyReader.hasChanges_ForNUnit)
+			if (readOnlyReader.hasChanges)
 			{
 				Assert.Fail("readOnlyReader has a write lock");
 			}
@@ -183,9 +183,9 @@ namespace Lucene.Net.Index
 			
 			TestIndexReaderReopen.CreateIndex(dir1, true);
 			IndexReader reader = IndexReader.Open(dir1, false);
-			int docCount = reader.NumDocs();
+			int docCount = reader.NumDocs;
 			Assert.IsTrue(DeleteWorked(1, reader));
-			Assert.AreEqual(docCount - 1, reader.NumDocs());
+			Assert.AreEqual(docCount - 1, reader.NumDocs);
 			
 			IndexReader readOnlyReader = reader.Reopen(true);
 			if (!IsReadOnly(readOnlyReader))
@@ -193,7 +193,7 @@ namespace Lucene.Net.Index
 				Assert.Fail("reader isn't read only");
 			}
 			Assert.IsFalse(DeleteWorked(1, readOnlyReader));
-			Assert.AreEqual(docCount - 1, readOnlyReader.NumDocs());
+			Assert.AreEqual(docCount - 1, readOnlyReader.NumDocs);
 			reader.Close();
 			readOnlyReader.Close();
 			dir1.Close();
@@ -215,7 +215,7 @@ namespace Lucene.Net.Index
 			}
 			Assert.IsFalse(DeleteWorked(1, reader1), "deleting from the original reader should not have worked");
 			// this readonly reader shouldn't yet have a write lock
-			if (reader2.hasChanges_ForNUnit)
+			if (reader2.hasChanges)
 			{
 				Assert.Fail("cloned reader should not have write lock");
 			}
@@ -518,7 +518,7 @@ namespace Lucene.Net.Index
 			TestIndexReaderReopen.CreateIndex(dir1, true);
 			IndexReader reader = IndexReader.Open(dir1, false);
 			reader.DeleteDocument(1); // acquire write lock
-			IndexReader[] subs = reader.GetSequentialSubReaders();
+			IndexReader[] subs = reader.SequentialSubReaders;
 			System.Diagnostics.Debug.Assert(subs.Length > 1);
 			
 			IndexReader[] clones = new IndexReader[subs.Length];
@@ -558,7 +558,7 @@ namespace Lucene.Net.Index
 		{
 			Directory dir = new MockRAMDirectory();
 			IndexWriter w = new IndexWriter(dir, new SimpleAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
-			w.SetUseCompoundFile(false);
+			w.UseCompoundFile = false;
 			Document doc = new Document();
 			doc.Add(new Field("field", "yes it's stored", Field.Store.YES, Field.Index.ANALYZED));
 			w.AddDocument(doc);

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexReaderCloneNorms.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexReaderCloneNorms.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexReaderCloneNorms.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexReaderCloneNorms.cs Mon Mar 12 22:29:26 2012
@@ -275,7 +275,7 @@ namespace Lucene.Net.Index
 			iw.SetMaxBufferedDocs(5);
 			iw.SetMergeFactor(3);
 			iw.SetSimilarity(similarityOne);
-			iw.SetUseCompoundFile(true);
+			iw.UseCompoundFile = true;
 			iw.Close();
 		}
 		
@@ -287,7 +287,7 @@ namespace Lucene.Net.Index
 		
 		private void  ModifyNormsForF1(IndexReader ir)
 		{
-			int n = ir.MaxDoc();
+			int n = ir.MaxDoc;
 			// System.out.println("modifyNormsForF1 maxDoc: "+n);
 			for (int i = 0; i < n; i += 3)
 			{
@@ -338,7 +338,7 @@ namespace Lucene.Net.Index
 			iw.SetMaxBufferedDocs(5);
 			iw.SetMergeFactor(3);
 			iw.SetSimilarity(similarityOne);
-			iw.SetUseCompoundFile(compound);
+			iw.UseCompoundFile = compound;
 			for (int i = 0; i < ndocs; i++)
 			{
 				iw.AddDocument(NewDoc());
@@ -354,7 +354,7 @@ namespace Lucene.Net.Index
 			for (int i = 0; i < 10; i++)
 			{
 				Field f = new Field("f" + i, "v" + i, Field.Store.NO, Field.Index.NOT_ANALYZED);
-				f.SetBoost(boost);
+				f.Boost = boost;
 				d.Add(f);
 			}
 			return d;

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexReaderReopen.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexReaderReopen.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexReaderReopen.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexReaderReopen.cs Mon Mar 12 22:29:26 2012
@@ -112,10 +112,10 @@ namespace Lucene.Net.Index
 						
 						
 						IndexSearcher searcher = new IndexSearcher(refreshed);
-						ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field1", "a" + rnd.Next(refreshed.MaxDoc()))), null, 1000).ScoreDocs;
+						ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field1", "a" + rnd.Next(refreshed.MaxDoc))), null, 1000).ScoreDocs;
 						if (hits.Length > 0)
 						{
-							searcher.Doc(hits[0].doc);
+							searcher.Doc(hits[0].Doc);
 						}
 						
 						// r might have changed because this is not a 
@@ -502,7 +502,7 @@ namespace Lucene.Net.Index
 				AssertRefCountEquals(1, reader0);
 				
 				Assert.IsTrue(reader0 is DirectoryReader);
-				IndexReader[] subReaders0 = reader0.GetSequentialSubReaders();
+				IndexReader[] subReaders0 = reader0.SequentialSubReaders;
 				for (int i = 0; i < subReaders0.Length; i++)
 				{
 					AssertRefCountEquals(1, subReaders0[i]);
@@ -515,7 +515,7 @@ namespace Lucene.Net.Index
 				
 				IndexReader reader1 = RefreshReader(reader0, true).refreshedReader;
 				Assert.IsTrue(reader1 is DirectoryReader);
-				IndexReader[] subReaders1 = reader1.GetSequentialSubReaders();
+				IndexReader[] subReaders1 = reader1.SequentialSubReaders;
 				Assert.AreEqual(subReaders0.Length, subReaders1.Length);
 				
 				for (int i = 0; i < subReaders0.Length; i++)
@@ -538,7 +538,7 @@ namespace Lucene.Net.Index
 				
 				IndexReader reader2 = RefreshReader(reader1, true).refreshedReader;
 				Assert.IsTrue(reader2 is DirectoryReader);
-				IndexReader[] subReaders2 = reader2.GetSequentialSubReaders();
+				IndexReader[] subReaders2 = reader2.SequentialSubReaders;
 				Assert.AreEqual(subReaders1.Length, subReaders2.Length);
 				
 				for (int i = 0; i < subReaders2.Length; i++)
@@ -572,7 +572,7 @@ namespace Lucene.Net.Index
 				
 				IndexReader reader3 = RefreshReader(reader0, true).refreshedReader;
 				Assert.IsTrue(reader3 is DirectoryReader);
-				IndexReader[] subReaders3 = reader3.GetSequentialSubReaders();
+				IndexReader[] subReaders3 = reader3.SequentialSubReaders;
 				Assert.AreEqual(subReaders3.Length, subReaders0.Length);
 				
 				// try some permutations
@@ -896,7 +896,7 @@ namespace Lucene.Net.Index
 		                                                          else if (i%3 == 1)
 		                                                          {
 		                                                              IndexReader modifier = IndexReader.Open(dir, false);
-		                                                              modifier.DeleteDocument(i%modifier.MaxDoc());
+		                                                              modifier.DeleteDocument(i%modifier.MaxDoc);
 		                                                              modifier.Close();
 		                                                          }
 		                                                          else
@@ -1129,11 +1129,11 @@ namespace Lucene.Net.Index
 			IndexReader r = IndexReader.Open(dir, false);
 			if (multiSegment)
 			{
-				Assert.IsTrue(r.GetSequentialSubReaders().Length > 1);
+				Assert.IsTrue(r.SequentialSubReaders.Length > 1);
 			}
 			else
 			{
-				Assert.IsTrue(r.GetSequentialSubReaders().Length == 1);
+				Assert.IsTrue(r.SequentialSubReaders.Length == 1);
 			}
 			r.Close();
 		}
@@ -1214,7 +1214,7 @@ namespace Lucene.Net.Index
 		
 		private void  AssertReaderClosed(IndexReader reader, bool checkSubReaders, bool checkNormsClosed)
 		{
-			Assert.AreEqual(0, reader.GetRefCount());
+			Assert.AreEqual(0, reader.RefCount);
 			
 			if (checkNormsClosed && reader is SegmentReader)
 			{
@@ -1225,7 +1225,7 @@ namespace Lucene.Net.Index
 			{
 				if (reader is DirectoryReader)
 				{
-					IndexReader[] subReaders = reader.GetSequentialSubReaders();
+					IndexReader[] subReaders = reader.SequentialSubReaders;
 					for (int i = 0; i < subReaders.Length; i++)
 					{
 						AssertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
@@ -1234,7 +1234,7 @@ namespace Lucene.Net.Index
 				
 				if (reader is MultiReader)
 				{
-					IndexReader[] subReaders = reader.GetSequentialSubReaders();
+					IndexReader[] subReaders = reader.SequentialSubReaders;
 					for (int i = 0; i < subReaders.Length; i++)
 					{
 						AssertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
@@ -1267,7 +1267,7 @@ namespace Lucene.Net.Index
 		
 		private void  AssertRefCountEquals(int refCount, IndexReader reader)
 		{
-			Assert.AreEqual(refCount, reader.GetRefCount(), "Reader has wrong refCount value.");
+			Assert.AreEqual(refCount, reader.RefCount, "Reader has wrong refCount value.");
 		}
 		
 		
@@ -1329,8 +1329,8 @@ namespace Lucene.Net.Index
 			IndexReader r2 = r1.Reopen(); // MSR
 			Assert.IsTrue(r1 != r2);
 			
-			SegmentReader sr1 = (SegmentReader) r1.GetSequentialSubReaders()[0]; // Get SRs for the first segment from original
-			SegmentReader sr2 = (SegmentReader) r2.GetSequentialSubReaders()[0]; // and reopened IRs
+			SegmentReader sr1 = (SegmentReader) r1.SequentialSubReaders[0]; // Get SRs for the first segment from original
+			SegmentReader sr2 = (SegmentReader) r2.SequentialSubReaders[0]; // and reopened IRs
 			
 			// At this point they share the same BitVector
 			Assert.IsTrue(sr1.deletedDocs_ForNUnit == sr2.deletedDocs_ForNUnit);
@@ -1363,7 +1363,7 @@ namespace Lucene.Net.Index
 			IndexReader r2 = r1.Reopen();
 			Assert.IsTrue(r1 != r2);
 			
-			IndexReader[] rs2 = r2.GetSequentialSubReaders();
+			IndexReader[] rs2 = r2.SequentialSubReaders;
 			
 			SegmentReader sr1 = SegmentReader.GetOnlySegmentReader(r1);
 			SegmentReader sr2 = (SegmentReader) rs2[0];
@@ -1413,8 +1413,8 @@ namespace Lucene.Net.Index
 			writer.Close();
 
             IndexReader r = IndexReader.Open(dir, false);
-			Assert.AreEqual(0, r.NumDocs());
-			Assert.AreEqual(4, r.MaxDoc());
+			Assert.AreEqual(0, r.NumDocs);
+			Assert.AreEqual(4, r.MaxDoc);
                         
 			System.Collections.IEnumerator it = IndexReader.ListCommits(dir).GetEnumerator();
 			while (it.MoveNext())
@@ -1434,7 +1434,7 @@ namespace Lucene.Net.Index
 					// expected
 				}
 
-                System.Collections.Generic.IDictionary<string, string> s = commit.GetUserData();
+                System.Collections.Generic.IDictionary<string, string> s = commit.UserData;
 				int v;
 				if (s.Count == 0)
 				{
@@ -1447,11 +1447,11 @@ namespace Lucene.Net.Index
 				}
 				if (v < 4)
 				{
-					Assert.AreEqual(1 + v, r2.NumDocs());
+					Assert.AreEqual(1 + v, r2.NumDocs);
 				}
 				else
 				{
-					Assert.AreEqual(7 - v, r2.NumDocs());
+					Assert.AreEqual(7 - v, r2.NumDocs);
 				}
 				r.Close();
 				r = r2;

Modified: incubator/lucene.net/trunk/test/core/Index/TestIndexWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Index/TestIndexWriter.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Index/TestIndexWriter.cs (original)
+++ incubator/lucene.net/trunk/test/core/Index/TestIndexWriter.cs Mon Mar 12 22:29:26 2012
@@ -378,7 +378,7 @@ namespace Lucene.Net.Index
                     return false;
                 ClearAttributes();
                 termAtt.SetTermBuffer((System.String)tokens.Current);
-                posIncrAtt.SetPositionIncrement(first ? 0 : 1);
+                posIncrAtt.PositionIncrement = first ? 0 : 1;
                 first = false;
                 return true;
             }
@@ -458,8 +458,8 @@ namespace Lucene.Net.Index
             writer.Close();
 
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(100, reader.MaxDoc());
-            Assert.AreEqual(60, reader.NumDocs());
+            Assert.AreEqual(100, reader.MaxDoc);
+            Assert.AreEqual(60, reader.NumDocs);
             reader.Close();
 
             // optimize the index and check that the new doc count is correct
@@ -473,8 +473,8 @@ namespace Lucene.Net.Index
 
             // check that the index reader gives the same numbers.
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(60, reader.MaxDoc());
-            Assert.AreEqual(60, reader.NumDocs());
+            Assert.AreEqual(60, reader.MaxDoc);
+            Assert.AreEqual(60, reader.NumDocs);
             reader.Close();
 
             // make sure opening a new index for create over
@@ -615,7 +615,7 @@ namespace Lucene.Net.Index
                     writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.UNLIMITED);
                     System.IO.IOException err = null;
 
-                    MergeScheduler ms = writer2.GetMergeScheduler();
+                    MergeScheduler ms = writer2.MergeScheduler;
                     for (int x = 0; x < 2; x++)
                     {
                         if (ms is ConcurrentMergeScheduler)
@@ -870,7 +870,7 @@ namespace Lucene.Net.Index
                     dir.SetMaxSizeInBytes(diskFree);
                     IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
 
-                    MergeScheduler ms = writer.GetMergeScheduler();
+                    MergeScheduler ms = writer.MergeScheduler;
                     if (ms is ConcurrentMergeScheduler)
                         // This test intentionally produces exceptions
                         // in the threads that CMS launches; we don't
@@ -999,7 +999,7 @@ namespace Lucene.Net.Index
 
             // Make sure the doc that has the massive term is in
             // the index:
-            Assert.AreEqual(2, reader.NumDocs(), "document with wicked long term should is not in the index!");
+            Assert.AreEqual(2, reader.NumDocs, "document with wicked long term should is not in the index!");
 
             reader.Close();
 
@@ -1008,7 +1008,7 @@ namespace Lucene.Net.Index
             doc = new Document();
             doc.Add(new Field("content", bigTerm, Field.Store.NO, Field.Index.ANALYZED));
             StandardAnalyzer sa = new StandardAnalyzer(Util.Version.LUCENE_CURRENT);
-            sa.SetMaxTokenLength(100000);
+            sa.MaxTokenLength = 100000;
             writer = new IndexWriter(dir, sa, IndexWriter.MaxFieldLength.LIMITED);
             writer.AddDocument(doc);
             writer.Close();
@@ -1031,7 +1031,7 @@ namespace Lucene.Net.Index
             {
                 IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
                 LogDocMergePolicy ldmp = new LogDocMergePolicy(writer);
-                ldmp.SetMinMergeDocs(1);
+                ldmp.MinMergeDocs = 1;
                 writer.SetMergePolicy(ldmp);
                 writer.SetMergeFactor(5);
                 writer.SetMaxBufferedDocs(2);
@@ -1070,7 +1070,7 @@ namespace Lucene.Net.Index
 
             IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
             LogDocMergePolicy ldmp = new LogDocMergePolicy(writer);
-            ldmp.SetMinMergeDocs(1);
+            ldmp.MinMergeDocs = 1;
             writer.SetMergePolicy(ldmp);
             writer.SetMergeFactor(4);
             writer.SetMaxBufferedDocs(2);
@@ -1093,7 +1093,7 @@ namespace Lucene.Net.Index
                 writer.Commit();
 
                 sis = new SegmentInfos();
-                ((ConcurrentMergeScheduler)writer.GetMergeScheduler()).Sync();
+                ((ConcurrentMergeScheduler)writer.MergeScheduler).Sync();
                 sis.Read(dir);
                 int optSegCount = sis.Count;
 
@@ -1176,7 +1176,7 @@ namespace Lucene.Net.Index
 
                 // now open reader:
                 IndexReader reader = IndexReader.Open(dir, true);
-                Assert.AreEqual(reader.NumDocs(), 1, "should be one document");
+                Assert.AreEqual(reader.NumDocs, 1, "should be one document");
 
                 // now open index for create:
                 writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
@@ -1184,9 +1184,9 @@ namespace Lucene.Net.Index
                 AddDoc(writer);
                 writer.Close();
 
-                Assert.AreEqual(reader.NumDocs(), 1, "should be one document");
+                Assert.AreEqual(reader.NumDocs, 1, "should be one document");
                 IndexReader reader2 = IndexReader.Open(dir, true);
-                Assert.AreEqual(reader2.NumDocs(), 1, "should be one document");
+                Assert.AreEqual(reader2.NumDocs, 1, "should be one document");
                 reader.Close();
                 reader2.Close();
             }
@@ -1427,12 +1427,12 @@ namespace Lucene.Net.Index
                 hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
                 Assert.AreEqual(14, hits.Length, "reader incorrectly sees changes from writer");
                 searcher.Close();
-                Assert.IsTrue(reader.IsCurrent(), "reader should have still been current");
+                Assert.IsTrue(reader.IsCurrent, "reader should have still been current");
             }
 
             // Now, close the writer:
             writer.Close();
-            Assert.IsFalse(reader.IsCurrent(), "reader should not be current now");
+            Assert.IsFalse(reader.IsCurrent, "reader should not be current now");
 
             searcher = new IndexSearcher(dir, false);
             hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
@@ -1592,7 +1592,7 @@ namespace Lucene.Net.Index
 
             // Reader should see index as unoptimized at this
             // point:
-            Assert.IsFalse(reader.IsOptimized(), "Reader incorrectly sees that the index is optimized");
+            Assert.IsFalse(reader.IsOptimized, "Reader incorrectly sees that the index is optimized");
             reader.Close();
 
             // Abort the writer:
@@ -1603,7 +1603,7 @@ namespace Lucene.Net.Index
             reader = IndexReader.Open(dir, true);
 
             // Reader should still see index as unoptimized:
-            Assert.IsFalse(reader.IsOptimized(), "Reader incorrectly sees that the index is optimized");
+            Assert.IsFalse(reader.IsOptimized, "Reader incorrectly sees that the index is optimized");
             reader.Close();
 
             writer = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -1615,7 +1615,7 @@ namespace Lucene.Net.Index
             reader = IndexReader.Open(dir, true);
 
             // Reader should still see index as unoptimized:
-            Assert.IsTrue(reader.IsOptimized(), "Reader incorrectly sees that the index is unoptimized");
+            Assert.IsTrue(reader.IsOptimized, "Reader incorrectly sees that the index is unoptimized");
             reader.Close();
         }
 
@@ -1628,8 +1628,8 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.MaxDoc());
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.MaxDoc);
+            Assert.AreEqual(0, reader.NumDocs);
             reader.Close();
 
             writer = new IndexWriter(dir, new WhitespaceAnalyzer(), false, IndexWriter.MaxFieldLength.LIMITED);
@@ -1637,8 +1637,8 @@ namespace Lucene.Net.Index
             writer.Close();
 
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.MaxDoc());
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.MaxDoc);
+            Assert.AreEqual(0, reader.NumDocs);
             reader.Close();
         }
 
@@ -1662,8 +1662,8 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(100, reader.MaxDoc());
-            Assert.AreEqual(100, reader.NumDocs());
+            Assert.AreEqual(100, reader.MaxDoc);
+            Assert.AreEqual(100, reader.NumDocs);
             for (int j = 0; j < 100; j++)
             {
                 Assert.AreEqual(1, reader.DocFreq(new Term("a" + j, "aaa" + j)));
@@ -1927,7 +1927,7 @@ namespace Lucene.Net.Index
                 Field f = new Field("field", "aaa", Field.Store.YES, Field.Index.ANALYZED);
                 if (j != 8)
                 {
-                    f.SetOmitNorms(true);
+                    f.OmitNorms = true;
                 }
                 doc.Add(f);
                 writer.AddDocument(doc);
@@ -1950,7 +1950,7 @@ namespace Lucene.Net.Index
                 Field f = new Field("field", "aaa", Field.Store.YES, Field.Index.ANALYZED);
                 if (j != 26)
                 {
-                    f.SetOmitNorms(true);
+                    f.OmitNorms = true;
                 }
                 doc.Add(f);
                 writer.AddDocument(doc);
@@ -1988,8 +1988,8 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(1, reader.MaxDoc());
-            Assert.AreEqual(1, reader.NumDocs());
+            Assert.AreEqual(1, reader.MaxDoc);
+            Assert.AreEqual(1, reader.NumDocs);
             Term t = new Term("field", "a");
             Assert.AreEqual(1, reader.DocFreq(t));
             TermDocs td = reader.TermDocs(t);
@@ -2062,7 +2062,7 @@ namespace Lucene.Net.Index
             writer.Close();
             _TestUtil.CheckIndex(dir);
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(2, reader.NumDocs());
+            Assert.AreEqual(2, reader.NumDocs);
         }
 
         // Test calling optimize(false) whereby optimize is kicked
@@ -2089,7 +2089,7 @@ namespace Lucene.Net.Index
                 {
                     writer.Close();
                     IndexReader reader = IndexReader.Open(dir, false);
-                    Assert.IsTrue(reader.IsOptimized());
+                    Assert.IsTrue(reader.IsOptimized);
                     reader.Close();
                 }
                 else
@@ -2101,7 +2101,7 @@ namespace Lucene.Net.Index
                     writer.Close();
 
                     IndexReader reader = IndexReader.Open(dir, true);
-                    Assert.IsTrue(!reader.IsOptimized());
+                    Assert.IsTrue(!reader.IsOptimized);
                     reader.Close();
 
                     SegmentInfos infos = new SegmentInfos();
@@ -2302,7 +2302,7 @@ namespace Lucene.Net.Index
             MockRAMDirectory dir = new MockRAMDirectory();
             IndexWriter iw = new IndexWriter(dir, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
             iw.SetMergeScheduler(new MyMergeScheduler(this));
-            iw.SetMaxMergeDocs(20);
+            iw.MaxMergeDocs = 20;
             iw.SetMaxBufferedDocs(2);
             iw.SetMergeFactor(2);
             Document document = new Document();
@@ -2513,9 +2513,9 @@ namespace Lucene.Net.Index
                 IndexReader reader = IndexReader.Open(dir, true);
                 int expected = 3 + (1 - i) * 2;
                 Assert.AreEqual(expected, reader.DocFreq(new Term("contents", "here")));
-                Assert.AreEqual(expected, reader.MaxDoc());
+                Assert.AreEqual(expected, reader.MaxDoc);
                 int numDel = 0;
-                for (int j = 0; j < reader.MaxDoc(); j++)
+                for (int j = 0; j < reader.MaxDoc; j++)
                 {
                     if (reader.IsDeleted(j))
                         numDel++;
@@ -2541,9 +2541,9 @@ namespace Lucene.Net.Index
                 reader = IndexReader.Open(dir, true);
                 expected = 19 + (1 - i) * 2;
                 Assert.AreEqual(expected, reader.DocFreq(new Term("contents", "here")));
-                Assert.AreEqual(expected, reader.MaxDoc());
+                Assert.AreEqual(expected, reader.MaxDoc);
                 numDel = 0;
-                for (int j = 0; j < reader.MaxDoc(); j++)
+                for (int j = 0; j < reader.MaxDoc; j++)
                 {
                     if (reader.IsDeleted(j))
                         numDel++;
@@ -2593,9 +2593,9 @@ namespace Lucene.Net.Index
                 IndexReader reader = IndexReader.Open(dir, true);
                 int expected = (3 + (1 - i) * 2) * NUM_THREAD * NUM_ITER;
                 Assert.AreEqual(expected, reader.DocFreq(new Term("contents", "here")));
-                Assert.AreEqual(expected, reader.MaxDoc());
+                Assert.AreEqual(expected, reader.MaxDoc);
                 int numDel = 0;
-                for (int j = 0; j < reader.MaxDoc(); j++)
+                for (int j = 0; j < reader.MaxDoc; j++)
                 {
                     if (reader.IsDeleted(j))
                         numDel++;
@@ -2621,9 +2621,9 @@ namespace Lucene.Net.Index
                 reader = IndexReader.Open(dir, true);
                 expected += 17 - NUM_THREAD * NUM_ITER;
                 Assert.AreEqual(expected, reader.DocFreq(new Term("contents", "here")));
-                Assert.AreEqual(expected, reader.MaxDoc());
+                Assert.AreEqual(expected, reader.MaxDoc);
                 numDel = 0;
-                for (int j = 0; j < reader.MaxDoc(); j++)
+                for (int j = 0; j < reader.MaxDoc; j++)
                 {
                     if (reader.IsDeleted(j))
                         numDel++;
@@ -2650,7 +2650,7 @@ namespace Lucene.Net.Index
                 IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
                 writer.SetMaxBufferedDocs(2);
                 writer.SetMergeFactor(2);
-                writer.SetUseCompoundFile(false);
+                writer.UseCompoundFile = false;
                 Document doc = new Document();
                 System.String contents = "aa bb cc dd ee ff gg hh ii jj kk";
 
@@ -2685,7 +2685,7 @@ namespace Lucene.Net.Index
                 if (0 == i % 4)
                 {
                     writer = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
-                    writer.SetUseCompoundFile(false);
+                    writer.UseCompoundFile = false;
                     writer.Optimize();
                     writer.Close();
                 }
@@ -3125,7 +3125,7 @@ namespace Lucene.Net.Index
                 if (success)
                 {
                     IndexReader reader = IndexReader.Open(dir, true);
-                    for (int j = 0; j < reader.MaxDoc(); j++)
+                    for (int j = 0; j < reader.MaxDoc; j++)
                     {
                         if (!reader.IsDeleted(j))
                         {
@@ -3365,24 +3365,24 @@ namespace Lucene.Net.Index
                 AddDoc(writer);
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
             writer.Commit();
             IndexReader reader2 = reader.Reopen();
-            Assert.AreEqual(0, reader.NumDocs());
-            Assert.AreEqual(23, reader2.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
+            Assert.AreEqual(23, reader2.NumDocs);
             reader.Close();
 
             for (int i = 0; i < 17; i++)
                 AddDoc(writer);
-            Assert.AreEqual(23, reader2.NumDocs());
+            Assert.AreEqual(23, reader2.NumDocs);
             reader2.Close();
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(23, reader.NumDocs());
+            Assert.AreEqual(23, reader.NumDocs);
             reader.Close();
             writer.Commit();
 
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(40, reader.NumDocs());
+            Assert.AreEqual(40, reader.NumDocs);
             reader.Close();
             writer.Close();
             dir.Close();
@@ -3449,7 +3449,7 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(23, reader.NumDocs());
+            Assert.AreEqual(23, reader.NumDocs);
             reader.Close();
             dir.Close();
         }
@@ -3487,7 +3487,7 @@ namespace Lucene.Net.Index
                 writer.Close();
 
                 IndexReader reader = IndexReader.Open(dir, true);
-                for (int i = 0; i < reader.NumDocs(); i++)
+                for (int i = 0; i < reader.NumDocs; i++)
                 {
                     reader.Document(i);
                     reader.GetTermFreqVectors(i);
@@ -3634,11 +3634,11 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader ir = IndexReader.Open(dir, false);
-            Assert.AreEqual(10, ir.MaxDoc());
-            Assert.AreEqual(10, ir.NumDocs());
+            Assert.AreEqual(10, ir.MaxDoc);
+            Assert.AreEqual(10, ir.NumDocs);
             ir.DeleteDocument(0);
             ir.DeleteDocument(7);
-            Assert.AreEqual(8, ir.NumDocs());
+            Assert.AreEqual(8, ir.NumDocs);
             ir.Close();
 
             writer = new IndexWriter(dir, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), IndexWriter.MaxFieldLength.LIMITED);
@@ -3648,8 +3648,8 @@ namespace Lucene.Net.Index
             Assert.AreEqual(8, writer.NumDocs());
             writer.Close();
             ir = IndexReader.Open(dir, true);
-            Assert.AreEqual(8, ir.MaxDoc());
-            Assert.AreEqual(8, ir.NumDocs());
+            Assert.AreEqual(8, ir.MaxDoc);
+            Assert.AreEqual(8, ir.NumDocs);
             ir.Close();
             dir.Close();
         }
@@ -3676,11 +3676,11 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader ir = IndexReader.Open(dir, false);
-            Assert.AreEqual(98, ir.MaxDoc());
-            Assert.AreEqual(98, ir.NumDocs());
+            Assert.AreEqual(98, ir.MaxDoc);
+            Assert.AreEqual(98, ir.NumDocs);
             for (int i = 0; i < 98; i += 2)
                 ir.DeleteDocument(i);
-            Assert.AreEqual(49, ir.NumDocs());
+            Assert.AreEqual(49, ir.NumDocs);
             ir.Close();
 
             writer = new IndexWriter(dir, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), IndexWriter.MaxFieldLength.LIMITED);
@@ -3689,8 +3689,8 @@ namespace Lucene.Net.Index
             writer.ExpungeDeletes();
             writer.Close();
             ir = IndexReader.Open(dir, true);
-            Assert.AreEqual(49, ir.MaxDoc());
-            Assert.AreEqual(49, ir.NumDocs());
+            Assert.AreEqual(49, ir.MaxDoc);
+            Assert.AreEqual(49, ir.NumDocs);
             ir.Close();
             dir.Close();
         }
@@ -3718,11 +3718,11 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader ir = IndexReader.Open(dir, false);
-            Assert.AreEqual(98, ir.MaxDoc());
-            Assert.AreEqual(98, ir.NumDocs());
+            Assert.AreEqual(98, ir.MaxDoc);
+            Assert.AreEqual(98, ir.NumDocs);
             for (int i = 0; i < 98; i += 2)
                 ir.DeleteDocument(i);
-            Assert.AreEqual(49, ir.NumDocs());
+            Assert.AreEqual(49, ir.NumDocs);
             ir.Close();
 
             writer = new IndexWriter(dir, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), IndexWriter.MaxFieldLength.LIMITED);
@@ -3731,8 +3731,8 @@ namespace Lucene.Net.Index
             writer.ExpungeDeletes(false);
             writer.Close();
             ir = IndexReader.Open(dir, true);
-            Assert.AreEqual(49, ir.MaxDoc());
-            Assert.AreEqual(49, ir.NumDocs());
+            Assert.AreEqual(49, ir.MaxDoc);
+            Assert.AreEqual(49, ir.NumDocs);
             ir.Close();
             dir.Close();
         }
@@ -3896,7 +3896,7 @@ namespace Lucene.Net.Index
                     break;
                 }
 
-            ((ConcurrentMergeScheduler)w.GetMergeScheduler()).Sync();
+            ((ConcurrentMergeScheduler)w.MergeScheduler).Sync();
             if (BuildType.Debug)
                 Assert.IsTrue(w.failed);
             else
@@ -3962,8 +3962,8 @@ namespace Lucene.Net.Index
             w.Close();
 
             IndexReader ir = IndexReader.Open(dir, true);
-            Assert.AreEqual(1, ir.MaxDoc());
-            Assert.AreEqual(0, ir.NumDocs());
+            Assert.AreEqual(1, ir.MaxDoc);
+            Assert.AreEqual(0, ir.NumDocs);
             ir.Close();
 
             dir.Close();
@@ -4061,7 +4061,7 @@ namespace Lucene.Net.Index
             for (int i = 0; i < count; i++)
             {
                 Assert.AreEqual(1, ir.DocFreq(new Term("f" + i, utf8Data[2 * i + 1])), "field " + i + " was not indexed correctly");
-                Assert.AreEqual(utf8Data[2 * i + 1], doc2.GetField("f" + i).StringValue(), "field " + i + " is incorrect");
+                Assert.AreEqual(utf8Data[2 * i + 1], doc2.GetField("f" + i).StringValue, "field " + i + " is incorrect");
             }
             ir.Close();
             dir.Close();
@@ -4290,7 +4290,7 @@ namespace Lucene.Net.Index
             Query q = new SpanTermQuery(new Term("field", "a"));
             hits = s.Search(q, null, 1000).ScoreDocs;
             Assert.AreEqual(1, hits.Length);
-            TermPositions tps = s.GetIndexReader().TermPositions(new Term("field", "a"));
+            TermPositions tps = s.IndexReader.TermPositions(new Term("field", "a"));
             Assert.IsTrue(tps.Next());
             Assert.AreEqual(1, tps.Freq());
             Assert.AreEqual(0, tps.NextPosition());
@@ -4315,40 +4315,40 @@ namespace Lucene.Net.Index
                 AddDoc(writer);
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
 
             writer.PrepareCommit();
 
             IndexReader reader2 = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader2.NumDocs());
+            Assert.AreEqual(0, reader2.NumDocs);
 
             writer.Commit();
 
             IndexReader reader3 = reader.Reopen();
-            Assert.AreEqual(0, reader.NumDocs());
-            Assert.AreEqual(0, reader2.NumDocs());
-            Assert.AreEqual(23, reader3.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
+            Assert.AreEqual(0, reader2.NumDocs);
+            Assert.AreEqual(23, reader3.NumDocs);
             reader.Close();
             reader2.Close();
 
             for (int i = 0; i < 17; i++)
                 AddDoc(writer);
 
-            Assert.AreEqual(23, reader3.NumDocs());
+            Assert.AreEqual(23, reader3.NumDocs);
             reader3.Close();
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(23, reader.NumDocs());
+            Assert.AreEqual(23, reader.NumDocs);
             reader.Close();
 
             writer.PrepareCommit();
 
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(23, reader.NumDocs());
+            Assert.AreEqual(23, reader.NumDocs);
             reader.Close();
 
             writer.Commit();
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(40, reader.NumDocs());
+            Assert.AreEqual(40, reader.NumDocs);
             reader.Close();
             writer.Close();
             dir.Close();
@@ -4370,19 +4370,19 @@ namespace Lucene.Net.Index
                 AddDoc(writer);
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
 
             writer.PrepareCommit();
 
             IndexReader reader2 = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader2.NumDocs());
+            Assert.AreEqual(0, reader2.NumDocs);
 
             writer.Rollback();
 
             IndexReader reader3 = reader.Reopen();
-            Assert.AreEqual(0, reader.NumDocs());
-            Assert.AreEqual(0, reader2.NumDocs());
-            Assert.AreEqual(0, reader3.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
+            Assert.AreEqual(0, reader2.NumDocs);
+            Assert.AreEqual(0, reader3.NumDocs);
             reader.Close();
             reader2.Close();
 
@@ -4390,21 +4390,21 @@ namespace Lucene.Net.Index
             for (int i = 0; i < 17; i++)
                 AddDoc(writer);
 
-            Assert.AreEqual(0, reader3.NumDocs());
+            Assert.AreEqual(0, reader3.NumDocs);
             reader3.Close();
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
             reader.Close();
 
             writer.PrepareCommit();
 
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
             reader.Close();
 
             writer.Commit();
             reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(17, reader.NumDocs());
+            Assert.AreEqual(17, reader.NumDocs);
             reader.Close();
             writer.Close();
             dir.Close();
@@ -4422,7 +4422,7 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader reader = IndexReader.Open(dir, true);
-            Assert.AreEqual(0, reader.NumDocs());
+            Assert.AreEqual(0, reader.NumDocs);
             reader.Close();
             dir.Close();
         }
@@ -4503,7 +4503,7 @@ namespace Lucene.Net.Index
 
                 dir2 = new MockRAMDirectory();
                 writer2 = new IndexWriter(dir2, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
-                cms = (ConcurrentMergeScheduler)writer2.GetMergeScheduler();
+                cms = (ConcurrentMergeScheduler)writer2.MergeScheduler;
 
                 readers = new IndexReader[NUM_COPY];
                 for (int i = 0; i < NUM_COPY; i++)
@@ -4625,7 +4625,7 @@ namespace Lucene.Net.Index
             _TestUtil.CheckIndex(c.dir2);
 
             IndexReader reader = IndexReader.Open(c.dir2, true);
-            Assert.AreEqual(100 + NUM_COPY * (3 * NUM_ITER / 4) * Lucene.Net.Index.TestIndexWriter.CommitAndAddIndexes.NUM_THREADS * Lucene.Net.Index.TestIndexWriter.CommitAndAddIndexes.NUM_INIT_DOCS, reader.NumDocs());
+            Assert.AreEqual(100 + NUM_COPY * (3 * NUM_ITER / 4) * Lucene.Net.Index.TestIndexWriter.CommitAndAddIndexes.NUM_THREADS * Lucene.Net.Index.TestIndexWriter.CommitAndAddIndexes.NUM_INIT_DOCS, reader.NumDocs);
             reader.Close();
 
             c.CloseDir();
@@ -4883,11 +4883,11 @@ namespace Lucene.Net.Index
 
             Document doc = new Document();
             Field f = new Field("binary", b, 10, 17, Field.Store.YES);
-            byte[] bx = f.GetBinaryValue();
+            byte[] bx = f.BinaryValue;
             Assert.IsTrue(bx != null);
             Assert.AreEqual(50, bx.Length);
-            Assert.AreEqual(10, f.GetBinaryOffset());
-            Assert.AreEqual(17, f.GetBinaryLength());
+            Assert.AreEqual(10, f.BinaryOffset);
+            Assert.AreEqual(17, f.BinaryLength);
             doc.Add(f);
             w.AddDocument(doc);
             w.Close();
@@ -4895,7 +4895,7 @@ namespace Lucene.Net.Index
             IndexReader ir = IndexReader.Open(dir, true);
             doc = ir.Document(0);
             f = doc.GetField("binary");
-            b = f.GetBinaryValue();
+            b = f.BinaryValue;
             Assert.IsTrue(b != null);
             Assert.AreEqual(17, b.Length, 17);
             Assert.AreEqual(87, b[0]);
@@ -4918,7 +4918,7 @@ namespace Lucene.Net.Index
 
             IndexReader r = IndexReader.Open(dir, true);
             // commit(Map) never called for this index
-            Assert.AreEqual(0, r.GetCommitUserData().Count);
+            Assert.AreEqual(0, r.CommitUserData.Count);
             r.Close();
 
             w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
@@ -4933,7 +4933,7 @@ namespace Lucene.Net.Index
             Assert.AreEqual("test1", IndexReader.GetCommitUserData(dir)["label"]);
 
             r = IndexReader.Open(dir, true);
-            Assert.AreEqual("test1", r.GetCommitUserData()["label"]);
+            Assert.AreEqual("test1", r.CommitUserData["label"]);
             r.Close();
 
             w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
@@ -4960,7 +4960,7 @@ namespace Lucene.Net.Index
             {
                 MockRAMDirectory dir = new MockRAMDirectory(startDir);
                 w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
-                ((ConcurrentMergeScheduler)w.GetMergeScheduler()).SetSuppressExceptions();
+                ((ConcurrentMergeScheduler)w.MergeScheduler).SetSuppressExceptions();
                 dir.SetRandomIOExceptionRate(0.5, 100);
                 try
                 {
@@ -5021,18 +5021,18 @@ namespace Lucene.Net.Index
 
             // Token "" occurred once
             Assert.AreEqual(1, termOffsets.Length);
-            Assert.AreEqual(8, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(8, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(8, termOffsets[0].StartOffset);
+            Assert.AreEqual(8, termOffsets[0].EndOffset);
 
             // Token "abcd" occurred three times
             termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(1);
             Assert.AreEqual(3, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(4, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(8, termOffsets[1].GetEndOffset());
-            Assert.AreEqual(8, termOffsets[2].GetStartOffset());
-            Assert.AreEqual(12, termOffsets[2].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(4, termOffsets[1].StartOffset);
+            Assert.AreEqual(8, termOffsets[1].EndOffset);
+            Assert.AreEqual(8, termOffsets[2].StartOffset);
+            Assert.AreEqual(12, termOffsets[2].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5053,10 +5053,10 @@ namespace Lucene.Net.Index
             IndexReader r = IndexReader.Open(dir, true);
             TermVectorOffsetInfo[] termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(0);
             Assert.AreEqual(2, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(5, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(9, termOffsets[1].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(5, termOffsets[1].StartOffset);
+            Assert.AreEqual(9, termOffsets[1].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5077,10 +5077,10 @@ namespace Lucene.Net.Index
             IndexReader r = IndexReader.Open(dir, true);
             TermVectorOffsetInfo[] termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(0);
             Assert.AreEqual(2, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(8, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(12, termOffsets[1].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(8, termOffsets[1].StartOffset);
+            Assert.AreEqual(12, termOffsets[1].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5103,10 +5103,10 @@ namespace Lucene.Net.Index
             IndexReader r = IndexReader.Open(dir, true);
             TermVectorOffsetInfo[] termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(0);
             Assert.AreEqual(2, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(8, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(12, termOffsets[1].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(8, termOffsets[1].StartOffset);
+            Assert.AreEqual(12, termOffsets[1].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5131,10 +5131,10 @@ namespace Lucene.Net.Index
             IndexReader r = IndexReader.Open(dir, true);
             TermVectorOffsetInfo[] termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(0);
             Assert.AreEqual(2, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(8, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(12, termOffsets[1].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(8, termOffsets[1].StartOffset);
+            Assert.AreEqual(12, termOffsets[1].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5155,10 +5155,10 @@ namespace Lucene.Net.Index
             IndexReader r = IndexReader.Open(dir, true);
             TermVectorOffsetInfo[] termOffsets = ((TermPositionVector)r.GetTermFreqVector(0, "field")).GetOffsets(0);
             Assert.AreEqual(2, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
-            Assert.AreEqual(9, termOffsets[1].GetStartOffset());
-            Assert.AreEqual(13, termOffsets[1].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
+            Assert.AreEqual(9, termOffsets[1].StartOffset);
+            Assert.AreEqual(13, termOffsets[1].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5181,14 +5181,14 @@ namespace Lucene.Net.Index
             TermPositionVector tpv = ((TermPositionVector)r.GetTermFreqVector(0, "field"));
             TermVectorOffsetInfo[] termOffsets = tpv.GetOffsets(0);
             Assert.AreEqual(1, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
             termOffsets = tpv.GetOffsets(1);
-            Assert.AreEqual(11, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(17, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(11, termOffsets[0].StartOffset);
+            Assert.AreEqual(17, termOffsets[0].EndOffset);
             termOffsets = tpv.GetOffsets(2);
-            Assert.AreEqual(18, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(21, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(18, termOffsets[0].StartOffset);
+            Assert.AreEqual(21, termOffsets[0].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5211,11 +5211,11 @@ namespace Lucene.Net.Index
             TermPositionVector tpv = ((TermPositionVector)r.GetTermFreqVector(0, "field"));
             TermVectorOffsetInfo[] termOffsets = tpv.GetOffsets(0);
             Assert.AreEqual(1, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(6, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(6, termOffsets[0].EndOffset);
             termOffsets = tpv.GetOffsets(1);
-            Assert.AreEqual(7, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(10, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(7, termOffsets[0].StartOffset);
+            Assert.AreEqual(10, termOffsets[0].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5242,11 +5242,11 @@ namespace Lucene.Net.Index
             TermPositionVector tpv = ((TermPositionVector)r.GetTermFreqVector(0, "field"));
             TermVectorOffsetInfo[] termOffsets = tpv.GetOffsets(0);
             Assert.AreEqual(1, termOffsets.Length);
-            Assert.AreEqual(0, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(4, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(0, termOffsets[0].StartOffset);
+            Assert.AreEqual(4, termOffsets[0].EndOffset);
             termOffsets = tpv.GetOffsets(1);
-            Assert.AreEqual(5, termOffsets[0].GetStartOffset());
-            Assert.AreEqual(11, termOffsets[0].GetEndOffset());
+            Assert.AreEqual(5, termOffsets[0].StartOffset);
+            Assert.AreEqual(11, termOffsets[0].EndOffset);
             r.Close();
             dir.Close();
         }
@@ -5308,7 +5308,7 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexReader r3 = IndexReader.Open(dir, true);
-            Assert.AreEqual(5, r3.NumDocs());
+            Assert.AreEqual(5, r3.NumDocs);
             r3.Close();
 
             r1.Close();
@@ -5514,14 +5514,14 @@ namespace Lucene.Net.Index
             IndexReader ir = IndexReader.Open(dir, true);
             doc = ir.Document(0);
             f = doc.GetField("binary");
-            b = f.GetBinaryValue();
+            b = f.BinaryValue;
             Assert.IsTrue(b != null);
             Assert.AreEqual(17, b.Length, 17);
             Assert.AreEqual(87, b[0]);
 
-            Assert.IsTrue(ir.Document(0).GetFieldable("binary").IsBinary());
-            Assert.IsTrue(ir.Document(1).GetFieldable("binary").IsBinary());
-            Assert.IsTrue(ir.Document(2).GetFieldable("binary").IsBinary());
+            Assert.IsTrue(ir.Document(0).GetFieldable("binary").IsBinary);
+            Assert.IsTrue(ir.Document(1).GetFieldable("binary").IsBinary);
+            Assert.IsTrue(ir.Document(2).GetFieldable("binary").IsBinary);
 
             Assert.AreEqual("value", ir.Document(0).Get("string"));
             Assert.AreEqual("value", ir.Document(1).Get("string"));
@@ -5556,18 +5556,18 @@ namespace Lucene.Net.Index
             System.Collections.IEnumerator it = doc.GetFields().GetEnumerator();
             Assert.IsTrue(it.MoveNext());
             Field f = (Field)it.Current;
-            Assert.AreEqual(f.Name(), "zzz");
-            Assert.AreEqual(f.StringValue(), "a b c");
+            Assert.AreEqual(f.Name, "zzz");
+            Assert.AreEqual(f.StringValue, "a b c");
 
             Assert.IsTrue(it.MoveNext());
             f = (Field)it.Current;
-            Assert.AreEqual(f.Name(), "aaa");
-            Assert.AreEqual(f.StringValue(), "a b c");
+            Assert.AreEqual(f.Name, "aaa");
+            Assert.AreEqual(f.StringValue, "a b c");
 
             Assert.IsTrue(it.MoveNext());
             f = (Field)it.Current;
-            Assert.AreEqual(f.Name(), "zzz");
-            Assert.AreEqual(f.StringValue(), "1 2 3");
+            Assert.AreEqual(f.Name, "zzz");
+            Assert.AreEqual(f.StringValue, "1 2 3");
             Assert.IsFalse(it.MoveNext());
             r.Close();
             w.Close();
@@ -5597,7 +5597,7 @@ namespace Lucene.Net.Index
         {
             Directory dir = new MockRAMDirectory();
             IndexWriter writer = new IndexWriter(dir, new SimpleAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
-            writer.SetUseCompoundFile(false);
+            writer.UseCompoundFile = false;
             //ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
             //writer.SetInfoStream(new PrintStream(bos));
             writer.AddDocument(new Document());
@@ -5729,7 +5729,7 @@ namespace Lucene.Net.Index
             IndexWriter w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
             w.SetMergeScheduler(new SerialMergeScheduler());
 
-            ((LogMergePolicy)w.GetMergePolicy()).SetMergeFactor(2);
+            ((LogMergePolicy)w.MergePolicy).MergeFactor = 2;
 
             Document doc = new Document();
             doc.Add(new Field("f", "doctor who", Field.Store.YES, Field.Index.ANALYZED));
@@ -5805,7 +5805,7 @@ namespace Lucene.Net.Index
             foreach(var c in IndexReader.ListCommits(dir))
             {
                 //string tag = c.GetUserData()["tag"];
-                var thing = c.GetUserData();
+                var thing = c.UserData;
                 string tag = thing["tag"];
                 if ("first".Equals(tag))
                 {
@@ -5830,7 +5830,7 @@ namespace Lucene.Net.Index
             commit = null;
             foreach(var c in IndexReader.ListCommits(dir))
             {
-                string tag = c.GetUserData()["tag"];
+                string tag = c.UserData["tag"];
                 if ("second".Equals(tag))
                 {
                     commit = c;
@@ -5841,12 +5841,12 @@ namespace Lucene.Net.Index
             Assert.NotNull(commit);
 
             IndexReader r = IndexReader.Open(commit, true);
-            Assert.AreEqual(2, r.NumDocs());
+            Assert.AreEqual(2, r.NumDocs);
             r.Close();
 
             // open "second", w/ writeable IndexReader & commit
             r = IndexReader.Open(commit, new NoDeletionPolicy(), false);
-            Assert.AreEqual(2, r.NumDocs());
+            Assert.AreEqual(2, r.NumDocs);
             r.DeleteDocument(0);
             r.DeleteDocument(1);
             commitData["tag"]="fourth";
@@ -5857,7 +5857,7 @@ namespace Lucene.Net.Index
             commit = null;
             foreach(var c in IndexReader.ListCommits(dir))
             {
-                string tag = c.GetUserData()["tag"];
+                string tag = c.UserData["tag"];
                 if ("third".Equals(tag))
                 {
                     commit = c;
@@ -5875,7 +5875,7 @@ namespace Lucene.Net.Index
             Directory dir = new MockRAMDirectory();
             IndexWriter indexWriter = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
             indexWriter.SetRAMBufferSizeMB(0.01);
-            indexWriter.SetUseCompoundFile(false);
+            indexWriter.UseCompoundFile = false;
 
             String BIG = "alskjhlaksjghlaksjfhalksvjepgjioefgjnsdfjgefgjhelkgjhqewlrkhgwlekgrhwelkgjhwelkgrhwlkejg";
             BIG = BIG + BIG + BIG + BIG;



Mime
View raw message