lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject svn commit: r1299911 [14/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/Search/TestTermRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTermRangeQuery.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTermRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTermRangeQuery.cs Mon Mar 12 22:29:26
2012
@@ -98,15 +98,15 @@ namespace Lucene.Net.Search
 		{
 			Query query = new TermRangeQuery("content", "A", "C", true, true);
 			
-			query.SetBoost(1.0f);
+			query.Boost = 1.0f;
 			Query other = new TermRangeQuery("content", "A", "C", true, true);
-			other.SetBoost(1.0f);
+			other.Boost = 1.0f;
 			
 			Assert.AreEqual(query, query, "query equals itself is true");
 			Assert.AreEqual(query, other, "equivalent queries are equal");
 			Assert.AreEqual(query.GetHashCode(), other.GetHashCode(), "hashcode must return same value
when equals is true");
 			
-			other.SetBoost(2.0f);
+			other.Boost = 2.0f;
 			Assert.IsFalse(query.Equals(other), "Different boost queries are not equal");
 			
 			other = new TermRangeQuery("notcontent", "A", "C", true, true);

Modified: incubator/lucene.net/trunk/test/core/Search/TestTermScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTermScorer.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTermScorer.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTermScorer.cs Mon Mar 12 22:29:26 2012
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search
 			}
 			writer.Close();
 		    indexSearcher = new IndexSearcher(directory, false);
-			indexReader = indexSearcher.GetIndexReader();
+			indexReader = indexSearcher.IndexReader;
 		}
 		
 		[Test]
@@ -115,7 +115,7 @@ namespace Lucene.Net.Search
 			
 			Weight weight = termQuery.Weight(indexSearcher);
 			
-			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.GetSimilarity(),
indexReader.Norms(FIELD));
+			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.Similarity,
indexReader.Norms(FIELD));
 			//we have 2 documents with the term all in them, one document for all the other values
 			System.Collections.IList docs = new System.Collections.ArrayList();
 			//must call next first
@@ -156,7 +156,7 @@ namespace Lucene.Net.Search
 			
 			Weight weight = termQuery.Weight(indexSearcher);
 			
-			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.GetSimilarity(),
indexReader.Norms(FIELD));
+			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.Similarity,
indexReader.Norms(FIELD));
 			Assert.IsTrue(ts.NextDoc() != DocIdSetIterator.NO_MORE_DOCS, "next did not return a doc");
 			Assert.IsTrue(ts.Score() == 1.6931472f, "score is not correct");
 			Assert.IsTrue(ts.NextDoc() != DocIdSetIterator.NO_MORE_DOCS, "next did not return a doc");
@@ -173,7 +173,7 @@ namespace Lucene.Net.Search
 			
 			Weight weight = termQuery.Weight(indexSearcher);
 			
-			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.GetSimilarity(),
indexReader.Norms(FIELD));
+			TermScorer ts = new TermScorer(weight, indexReader.TermDocs(allTerm), indexSearcher.Similarity,
indexReader.Norms(FIELD));
 			Assert.IsTrue(ts.Advance(3) != DocIdSetIterator.NO_MORE_DOCS, "Didn't skip");
 			//The next doc should be doc 5
 			Assert.IsTrue(ts.DocID() == 5, "doc should be number 5");

Modified: incubator/lucene.net/trunk/test/core/Search/TestTermVectors.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTermVectors.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTermVectors.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTermVectors.cs Mon Mar 12 22:29:26 2012
@@ -90,7 +90,7 @@ namespace Lucene.Net.Search
 				
 				for (int i = 0; i < hits.Length; i++)
 				{
-					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].doc);
+					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].Doc);
 					Assert.IsTrue(vector != null);
 					Assert.IsTrue(vector.Length == 1);
 				}
@@ -147,14 +147,14 @@ namespace Lucene.Net.Search
 				
 				for (int i = 0; i < hits.Length; i++)
 				{
-					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].doc);
+					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].Doc);
 					Assert.IsTrue(vector != null);
 					Assert.IsTrue(vector.Length == 1);
 					
-					bool shouldBePosVector = (hits[i].doc % 2 == 0)?true:false;
+					bool shouldBePosVector = (hits[i].Doc % 2 == 0)?true:false;
 					Assert.IsTrue((shouldBePosVector == false) || (shouldBePosVector == true &&
(vector[0] is TermPositionVector == true)));
 					
-					bool shouldBeOffVector = (hits[i].doc % 3 == 0)?true:false;
+					bool shouldBeOffVector = (hits[i].Doc % 3 == 0)?true:false;
 					Assert.IsTrue((shouldBeOffVector == false) || (shouldBeOffVector == true &&
(vector[0] is TermPositionVector == true)));
 					
 					if (shouldBePosVector || shouldBeOffVector)
@@ -218,7 +218,7 @@ namespace Lucene.Net.Search
 				
 				for (int i = 0; i < hits.Length; i++)
 				{
-					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].doc);
+					TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].Doc);
 					Assert.IsTrue(vector != null);
 					Assert.IsTrue(vector.Length == 1);
 					
@@ -276,7 +276,7 @@ namespace Lucene.Net.Search
 				TermDocs termDocs = knownSearcher.reader_ForNUnit.TermDocs();
 				//System.out.println("Terms: " + termEnum.size() + " Orig Len: " + termArray.length);
 				
-				Similarity sim = knownSearcher.GetSimilarity();
+				Similarity sim = knownSearcher.Similarity;
 				while (termEnum.Next() == true)
 				{
 					Term term = termEnum.Term();
@@ -312,17 +312,17 @@ namespace Lucene.Net.Search
 				ScoreDoc[] hits = knownSearcher.Search(query, null, 1000).ScoreDocs;
 				//doc 3 should be the first hit b/c it is the shortest match
 				Assert.IsTrue(hits.Length == 3);
-				float score = hits[0].score;
+				float score = hits[0].Score;
 				/*System.out.println("Hit 0: " + hits.id(0) + " Score: " + hits.score(0) + " String:
" + hits.doc(0).toString());
 				System.out.println("Explain: " + knownSearcher.explain(query, hits.id(0)));
 				System.out.println("Hit 1: " + hits.id(1) + " Score: " + hits.score(1) + " String: "
+ hits.doc(1).toString());
 				System.out.println("Explain: " + knownSearcher.explain(query, hits.id(1)));
 				System.out.println("Hit 2: " + hits.id(2) + " Score: " + hits.score(2) + " String: "
+  hits.doc(2).toString());
 				System.out.println("Explain: " + knownSearcher.explain(query, hits.id(2)));*/
-				Assert.IsTrue(hits[0].doc == 2);
-				Assert.IsTrue(hits[1].doc == 3);
-				Assert.IsTrue(hits[2].doc == 0);
-				TermFreqVector vector2 = knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].doc,
"field");
+				Assert.IsTrue(hits[0].Doc == 2);
+				Assert.IsTrue(hits[1].Doc == 3);
+				Assert.IsTrue(hits[2].Doc == 0);
+				TermFreqVector vector2 = knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].Doc,
"field");
 				Assert.IsTrue(vector2 != null);
 				//System.out.println("Vector: " + vector);
 				System.String[] terms = vector2.GetTerms();
@@ -346,25 +346,25 @@ namespace Lucene.Net.Search
 					Assert.IsTrue(freqInt == freq);
 				}
 				SortedTermVectorMapper mapper = new SortedTermVectorMapper(new TermVectorEntryFreqSortedComparator());
-				knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].doc, mapper);
-				var vectorEntrySet = mapper.GetTermVectorEntrySet();
+				knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].Doc, mapper);
+				var vectorEntrySet = mapper.TermVectorEntrySet;
 				Assert.IsTrue(vectorEntrySet.Count == 10, "mapper.getTermVectorEntrySet() Size: " + vectorEntrySet.Count
+ " is not: " + 10);
 				TermVectorEntry last = null;
                 foreach(TermVectorEntry tve in vectorEntrySet)
 				{
 					if (tve != null && last != null)
 					{
-						Assert.IsTrue(last.GetFrequency() >= tve.GetFrequency(), "terms are not properly
sorted");
-						System.Int32 expectedFreq = (System.Int32) test4Map[tve.GetTerm()];
+						Assert.IsTrue(last.Frequency >= tve.Frequency, "terms are not properly sorted");
+						System.Int32 expectedFreq = (System.Int32) test4Map[tve.Term];
 						//we expect double the expectedFreq, since there are two fields with the exact same
text and we are collapsing all fields
-						Assert.IsTrue(tve.GetFrequency() == 2 * expectedFreq, "Frequency is not correct:");
+						Assert.IsTrue(tve.Frequency == 2 * expectedFreq, "Frequency is not correct:");
 					}
 					last = tve;
 				}
 				
 				FieldSortedTermVectorMapper fieldMapper = new FieldSortedTermVectorMapper(new TermVectorEntryFreqSortedComparator());
-				knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].doc, fieldMapper);
-				var map = fieldMapper.GetFieldToTerms();
+				knownSearcher.reader_ForNUnit.GetTermFreqVector(hits[1].Doc, fieldMapper);
+				var map = fieldMapper.FieldToTerms;
 				Assert.IsTrue(map.Count == 2, "map Size: " + map.Count + " is not: " + 2);
 				vectorEntrySet = map["field"];
 				Assert.IsTrue(vectorEntrySet != null, "vectorEntrySet is null and it shouldn't be");
@@ -411,7 +411,7 @@ namespace Lucene.Net.Search
 			Assert.AreEqual(10, hits.Length);
 			for (int i = 0; i < hits.Length; i++)
 			{
-				TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].doc);
+				TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[i].Doc);
 				Assert.IsTrue(vector != null);
 				Assert.IsTrue(vector.Length == 1);
 			}
@@ -439,7 +439,7 @@ namespace Lucene.Net.Search
 			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
-			TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[0].doc);
+			TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[0].Doc);
 			Assert.IsTrue(vector != null);
 			Assert.IsTrue(vector.Length == 1);
 			TermPositionVector tfv = (TermPositionVector) vector[0];
@@ -457,8 +457,8 @@ namespace Lucene.Net.Search
 			Assert.AreEqual(5, offsets.Length);
 			for (int i = 0; i < 5; i++)
 			{
-				Assert.AreEqual(4 * i, offsets[i].GetStartOffset());
-				Assert.AreEqual(4 * i + 3, offsets[i].GetEndOffset());
+				Assert.AreEqual(4 * i, offsets[i].StartOffset);
+				Assert.AreEqual(4 * i + 3, offsets[i].EndOffset);
 			}
 		}
 	}

Modified: incubator/lucene.net/trunk/test/core/Search/TestThreadSafe.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestThreadSafe.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestThreadSafe.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestThreadSafe.cs Mon Mar 12 22:29:26 2012
@@ -131,21 +131,21 @@ namespace Lucene.Net.Search
 			internal virtual void  loadDoc(IndexReader ir)
 			{
 				// beware of deleted docs in the future
-				Document doc = ir.Document(rand.Next(ir.MaxDoc()), new AnonymousClassFieldSelector(this));
+				Document doc = ir.Document(rand.Next(ir.MaxDoc), new AnonymousClassFieldSelector(this));
 				
 				var fields = doc.GetFields();
 				for (int i = 0; i < fields.Count; i++)
 				{
-					Fieldable f = fields[i];
+					IFieldable f = fields[i];
 					Enclosing_Instance.ValidateField(f);
 				}
 			}
 		}
 		
 		
-		internal virtual void  ValidateField(Fieldable f)
+		internal virtual void  ValidateField(IFieldable f)
 		{
-			System.String val = f.StringValue();
+			System.String val = f.StringValue;
 			if (!val.StartsWith("^") || !val.EndsWith("$"))
 			{
 				throw new System.SystemException("Invalid field:" + f.ToString() + " val=" + val);

Modified: incubator/lucene.net/trunk/test/core/Search/TestTimeLimitingCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTimeLimitingCollector.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTimeLimitingCollector.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTimeLimitingCollector.cs Mon Mar 12 22:29:26
2012
@@ -183,7 +183,7 @@ namespace Lucene.Net.Search
 		private Collector CreateTimedCollector(MyHitCollector hc, long timeAllowed, bool greedy)
 		{
 			TimeLimitingCollector res = new TimeLimitingCollector(hc, timeAllowed);
-			res.SetGreedy(greedy); // set to true to make sure at least one doc is collected.
+			res.IsGreedy = greedy; // set to true to make sure at least one doc is collected.
 			return res;
 		}
 		
@@ -227,7 +227,7 @@ namespace Lucene.Net.Search
 			Assert.IsNotNull(timoutException, "Timeout expected!");
 			
 			// greediness affect last doc collected
-			int exceptionDoc = timoutException.GetLastDocCollected();
+			int exceptionDoc = timoutException.LastDocCollected;
 			int lastCollected = myHc.GetLastDocCollected();
 			Assert.IsTrue(exceptionDoc > 0, "doc collected at timeout must be > 0!");
 			if (greedy)
@@ -241,21 +241,21 @@ namespace Lucene.Net.Search
 			}
 			
 			// verify that elapsed time at exception is within valid limits
-			Assert.AreEqual(timoutException.GetTimeAllowed(), TIME_ALLOWED);
+			Assert.AreEqual(timoutException.TimeAllowed, TIME_ALLOWED);
 			// a) Not too early
-			Assert.IsTrue(timoutException.GetTimeElapsed() > TIME_ALLOWED - TimeLimitingCollector.GetResolution(),
"elapsed=" + timoutException.GetTimeElapsed() + " <= (allowed-resolution)=" + (TIME_ALLOWED
- TimeLimitingCollector.GetResolution()));
+			Assert.IsTrue(timoutException.TimeElapsed > TIME_ALLOWED - TimeLimitingCollector.Resolution,
"elapsed=" + timoutException.TimeElapsed + " <= (allowed-resolution)=" + (TIME_ALLOWED
- TimeLimitingCollector.Resolution));
 			// b) Not too late.
 			//    This part is problematic in a busy test system, so we just print a warning.
 			//    We already verified that a timeout occurred, we just can't be picky about how long
it took.
-			if (timoutException.GetTimeElapsed() > MaxTime(multiThreaded))
+			if (timoutException.TimeElapsed > MaxTime(multiThreaded))
 			{
-				System.Console.Out.WriteLine("Informative: timeout exceeded (no action required: most
probably just " + " because the test machine is slower than usual):  " + "lastDoc=" + exceptionDoc
+ " ,&& allowed=" + timoutException.GetTimeAllowed() + " ,&& elapsed=" + timoutException.GetTimeElapsed()
+ " >= " + MaxTimeStr(multiThreaded));
+				System.Console.Out.WriteLine("Informative: timeout exceeded (no action required: most
probably just " + " because the test machine is slower than usual):  " + "lastDoc=" + exceptionDoc
+ " ,&& allowed=" + timoutException.TimeAllowed + " ,&& elapsed=" + timoutException.TimeElapsed
+ " >= " + MaxTimeStr(multiThreaded));
 			}
 		}
 		
 		private long MaxTime(bool multiThreaded)
 		{
-			long res = 2 * TimeLimitingCollector.GetResolution() + TIME_ALLOWED + SLOW_DOWN; // some
slack for less noise in this test
+			long res = 2 * TimeLimitingCollector.Resolution + TIME_ALLOWED + SLOW_DOWN; // some slack
for less noise in this test
 			if (multiThreaded)
 			{
 				res = (long) (res * MULTI_THREAD_SLACK); // larger slack  
@@ -265,7 +265,7 @@ namespace Lucene.Net.Search
 		
 		private System.String MaxTimeStr(bool multiThreaded)
 		{
-			System.String s = "( " + "2*resolution +  TIME_ALLOWED + SLOW_DOWN = " + "2*" + TimeLimitingCollector.GetResolution()
+ " + " + TIME_ALLOWED + " + " + SLOW_DOWN + ")";
+			System.String s = "( " + "2*resolution +  TIME_ALLOWED + SLOW_DOWN = " + "2*" + TimeLimitingCollector.Resolution
+ " + " + TIME_ALLOWED + " + " + SLOW_DOWN + ")";
 			if (multiThreaded)
 			{
 				s = MULTI_THREAD_SLACK + " * " + s;
@@ -281,23 +281,23 @@ namespace Lucene.Net.Search
 			{
 				// increase and test
 				uint resolution = 20 * TimeLimitingCollector.DEFAULT_RESOLUTION; //400
-				TimeLimitingCollector.SetResolution(resolution);
-				Assert.AreEqual(resolution, TimeLimitingCollector.GetResolution());
+				TimeLimitingCollector.Resolution = resolution;
+				Assert.AreEqual(resolution, TimeLimitingCollector.Resolution);
 				DoTestTimeout(false, true);
 				// decrease much and test
 				resolution = 5;
-				TimeLimitingCollector.SetResolution(resolution);
-				Assert.AreEqual(resolution, TimeLimitingCollector.GetResolution());
+                TimeLimitingCollector.Resolution = resolution;
+				Assert.AreEqual(resolution, TimeLimitingCollector.Resolution);
 				DoTestTimeout(false, true);
 				// return to default and test
 				resolution = TimeLimitingCollector.DEFAULT_RESOLUTION;
-				TimeLimitingCollector.SetResolution(resolution);
-				Assert.AreEqual(resolution, TimeLimitingCollector.GetResolution());
+                TimeLimitingCollector.Resolution = resolution;
+				Assert.AreEqual(resolution, TimeLimitingCollector.Resolution);
 				DoTestTimeout(false, true);
 			}
 			finally
 			{
-				TimeLimitingCollector.SetResolution(TimeLimitingCollector.DEFAULT_RESOLUTION);
+                TimeLimitingCollector.Resolution = TimeLimitingCollector.DEFAULT_RESOLUTION;
 			}
 		}
 		

Modified: incubator/lucene.net/trunk/test/core/Search/TestTopDocsCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTopDocsCollector.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTopDocsCollector.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTopDocsCollector.cs Mon Mar 12 22:29:26
2012
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search
 				float maxScore = System.Single.NaN;
 				if (start == 0)
 				{
-					maxScore = results[0].score;
+					maxScore = results[0].Score;
 				}
 				else
 				{
@@ -63,7 +63,7 @@ namespace Lucene.Net.Search
 					{
 						pq.Pop();
 					}
-					maxScore = pq.Pop().score;
+					maxScore = pq.Pop().Score;
 				}
 				
 				return new TopDocs(totalHits, results, maxScore);
@@ -210,12 +210,12 @@ namespace Lucene.Net.Search
 			// ask for all results
 			TopDocsCollector<ScoreDoc> tdc = doSearch(15);
 			TopDocs td = tdc.TopDocs();
-			Assert.AreEqual(MAX_SCORE, td.GetMaxScore(), 0f);
+            Assert.AreEqual(MAX_SCORE, td.MaxScore, 0f);
 			
 			// ask for 5 last results
 			tdc = doSearch(15);
 			td = tdc.TopDocs(10);
-			Assert.AreEqual(MAX_SCORE, td.GetMaxScore(), 0f);
+            Assert.AreEqual(MAX_SCORE, td.MaxScore, 0f);
 		}
 		
 		// This does not test the PQ's correctness, but whether topDocs()
@@ -226,10 +226,10 @@ namespace Lucene.Net.Search
 			TopDocsCollector<ScoreDoc> tdc = doSearch(15);
 			ScoreDoc[] sd = tdc.TopDocs().ScoreDocs;
 			
-			Assert.AreEqual(MAX_SCORE, sd[0].score, 0f);
+			Assert.AreEqual(MAX_SCORE, sd[0].Score, 0f);
 			for (int i = 1; i < sd.Length; i++)
 			{
-				Assert.IsTrue(sd[i - 1].score >= sd[i].score);
+				Assert.IsTrue(sd[i - 1].Score >= sd[i].Score);
 			}
 		}
 	}

Modified: incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs Mon Mar 12 22:29:26
2012
@@ -78,7 +78,7 @@ namespace Lucene.Net.Search
                 Assert.AreEqual(3, sd.Length);
                 for (int j = 0; j < sd.Length; j++)
                 {
-                    Assert.AreEqual(j, sd[j].doc, "expected doc Id " + j + " found " + sd[j].doc);
+                    Assert.AreEqual(j, sd[j].Doc, "expected doc Id " + j + " found " + sd[j].Doc);
                 }
             }
         }

Modified: incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs Mon Mar 12 22:29:26 2012
@@ -73,29 +73,29 @@ namespace Lucene.Net.Search
 		    MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
 		    AssertMatches(searcher, wq, 1);
 
-		    wq.SetRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
-		    wq.SetBoost(0.1f);
+		    wq.QueryRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
+		    wq.Boost = 0.1f;
 		    Query q = searcher.Rewrite(wq);
 		    Assert.IsTrue(q is TermQuery);
-		    Assert.AreEqual(q.GetBoost(), wq.GetBoost());
+		    Assert.AreEqual(q.Boost, wq.Boost);
 
-		    wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
-		    wq.SetBoost(0.2f);
+		    wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
+		    wq.Boost = 0.2f;
 		    q = searcher.Rewrite(wq);
 		    Assert.True(q is ConstantScoreQuery);
-		    Assert.AreEqual(q.GetBoost(), wq.GetBoost());
+		    Assert.AreEqual(q.Boost, wq.Boost);
 
-		    wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
-		    wq.SetBoost(0.3F);
+		    wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
+		    wq.Boost = 0.3F;
 		    q = searcher.Rewrite(wq);
 		    Assert.True(q is ConstantScoreQuery);
-		    Assert.AreEqual(q.GetBoost(), wq.GetBoost());
+		    Assert.AreEqual(q.Boost, wq.Boost);
 
-		    wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE);
-		    wq.SetBoost(0.4F);
+		    wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
+		    wq.Boost = 0.4F;
 		    q = searcher.Rewrite(wq);
 		    Assert.True(q is ConstantScoreQuery);
-		    Assert.AreEqual(q.GetBoost(), wq.GetBoost());
+		    Assert.AreEqual(q.Boost, wq.Boost);
 		}
 
         /// <summary>
@@ -108,7 +108,7 @@ namespace Lucene.Net.Search
             IndexSearcher searcher = new IndexSearcher(indexStore, true);
 
             MultiTermQuery wq = new WildcardQuery(new Term("field", ""));
-            wq.SetRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
+            wq.QueryRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
             AssertMatches(searcher, wq, 0);
             BooleanQuery expected = new BooleanQuery(true);
             Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
@@ -129,28 +129,28 @@ namespace Lucene.Net.Search
             AssertMatches(searcher, wq, 2);
 
             MultiTermQuery expected = new PrefixQuery(new Term("field", "prefix"));
-            wq.SetRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
-            wq.SetBoost(0.1F);
-            expected.SetRewriteMethod(wq.GetRewriteMethod());
-            expected.SetBoost(wq.GetBoost());
+            wq.QueryRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
+            wq.Boost = 0.1F;
+            expected.QueryRewriteMethod = wq.QueryRewriteMethod;
+            expected.Boost = wq.Boost;
             Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
 
-            wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
-            wq.SetBoost(0.2F);
-            expected.SetRewriteMethod(wq.GetRewriteMethod());
-            expected.SetBoost(wq.GetBoost());
+            wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
+            wq.Boost = 0.2F;
+            expected.QueryRewriteMethod = wq.QueryRewriteMethod;
+            expected.Boost = wq.Boost;
             Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
 
-            wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT);
-            wq.SetBoost(0.3F);
-            expected.SetRewriteMethod(wq.GetRewriteMethod());
-            expected.SetBoost(wq.GetBoost());
+            wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
+            wq.Boost = 0.3F;
+            expected.QueryRewriteMethod = wq.QueryRewriteMethod;
+            expected.Boost = wq.Boost;
             Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
 
-            wq.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE);
-            wq.SetBoost(0.4F);
-            expected.SetRewriteMethod(wq.GetRewriteMethod());
-            expected.SetBoost(wq.GetBoost());
+            wq.QueryRewriteMethod = MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
+            wq.Boost = 0.4F;
+            expected.QueryRewriteMethod = wq.QueryRewriteMethod;
+            expected.Boost = wq.Boost;
             Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
         }
 
@@ -268,7 +268,7 @@ namespace Lucene.Net.Search
 			System.String field = "content";
 			bool dbg = false;
 			QueryParser qp = new QueryParser(Util.Version.LUCENE_CURRENT, field, new WhitespaceAnalyzer());
-			qp.SetAllowLeadingWildcard(true);
+			qp.AllowLeadingWildcard = true;
 			System.String[] docs = new System.String[]{"\\ abcdefg1", "\\79 hijklmn1", "\\\\ opqrstu1"};
 			// queries that should find all docs
 			System.String[] matchAll = new System.String[]{"*", "*1", "**1", "*?", "*?1", "?*1", "**",
"***", "\\\\*"};
@@ -332,7 +332,7 @@ namespace Lucene.Net.Search
 					Assert.AreEqual(typeof(PrefixQuery), q.GetType());
 					ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 					Assert.AreEqual(1, hits.Length);
-					Assert.AreEqual(i, hits[0].doc);
+					Assert.AreEqual(i, hits[0].Doc);
 				}
 			}
 			
@@ -350,7 +350,7 @@ namespace Lucene.Net.Search
 					Assert.AreEqual(typeof(WildcardQuery), q.GetType());
 					ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 					Assert.AreEqual(1, hits.Length);
-					Assert.AreEqual(i, hits[0].doc);
+					Assert.AreEqual(i, hits[0].Doc);
 				}
 			}
 			

Modified: incubator/lucene.net/trunk/test/core/Store/MockRAMDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/MockRAMDirectory.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/MockRAMDirectory.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/MockRAMDirectory.cs Mon Mar 12 22:29:26 2012
@@ -130,7 +130,7 @@ namespace Lucene.Net.Store
                     else if (count % 3 == 2)
                     {
                         // Truncate the file:
-                        file.SetLength(file.GetLength() / 2);
+                        file.Length = file.Length / 2;
                     }
                     count++;
                 }
@@ -276,8 +276,8 @@ namespace Lucene.Net.Store
                 {
                     if (existing != null)
                     {
-                        _sizeInBytes -= existing.sizeInBytes_ForNUnit;
-                        existing.directory_ForNUnit = null;
+                        _sizeInBytes -= existing.sizeInBytes;
+                        existing.directory = null;
                     }
 
                     fileMap[name]=file;
@@ -318,7 +318,7 @@ namespace Lucene.Net.Store
             {
                 long size = 0;
                 foreach(RAMFile file in fileMap.Values)
-                    size += file.GetSizeInBytes();
+                    size += file.SizeInBytes;
                 return size;
             }
         }

Modified: incubator/lucene.net/trunk/test/core/Store/TestBufferedIndexInput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/TestBufferedIndexInput.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/TestBufferedIndexInput.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/TestBufferedIndexInput.cs Mon Mar 12 22:29:26
2012
@@ -179,8 +179,8 @@ namespace Lucene.Net.Store
 			// add an arbitrary offset at the beginning of the array
 			int offset = size % 10; // arbitrary
 			buffer = ArrayUtil.Grow(buffer, offset + size);
-			Assert.AreEqual(pos, input.GetFilePointer());
-			long left = TEST_FILE_LENGTH - input.GetFilePointer();
+			Assert.AreEqual(pos, input.FilePointer);
+			long left = TEST_FILE_LENGTH - input.FilePointer;
 			if (left <= 0)
 			{
 				return ;
@@ -190,7 +190,7 @@ namespace Lucene.Net.Store
 				size = (int) left;
 			}
 			input.ReadBytes(buffer, offset, size);
-			Assert.AreEqual(pos + size, input.GetFilePointer());
+			Assert.AreEqual(pos + size, input.FilePointer);
 			for (int i = 0; i < size; i++)
 			{
 				Assert.AreEqual(Byten(pos + i), buffer[offset + i], "pos=" + i + " filepos=" + (pos +
i));
@@ -291,7 +291,7 @@ namespace Lucene.Net.Store
 			try
 			{
 				IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
-				writer.SetUseCompoundFile(false);
+				writer.UseCompoundFile = false;
 				for (int i = 0; i < 37; i++)
 				{
 					Document doc = new Document();

Modified: incubator/lucene.net/trunk/test/core/Store/TestFileSwitchDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/TestFileSwitchDirectory.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/TestFileSwitchDirectory.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/TestFileSwitchDirectory.cs Mon Mar 12 22:29:26
2012
@@ -46,10 +46,10 @@ namespace Lucene.Net.Store
 			
 			FileSwitchDirectory fsd = new FileSwitchDirectory(fileExtensions, primaryDir, secondaryDir,
true);
 			IndexWriter writer = new IndexWriter(fsd, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.LIMITED);
-			writer.SetUseCompoundFile(false);
+			writer.UseCompoundFile = false;
 			TestIndexWriterReader.CreateIndexNoClose(true, "ram", writer);
 			IndexReader reader = writer.GetReader();
-			Assert.AreEqual(100, reader.MaxDoc());
+			Assert.AreEqual(100, reader.MaxDoc);
 			writer.Commit();
 			// we should see only fdx,fdt files here
 			System.String[] files = primaryDir.ListAll();

Modified: incubator/lucene.net/trunk/test/core/Store/TestHugeRamFile.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/TestHugeRamFile.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/TestHugeRamFile.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/TestHugeRamFile.cs Mon Mar 12 22:29:26 2012
@@ -77,13 +77,13 @@ namespace Lucene.Net.Store
 				b2[i] = (byte) (i & 0x0003F);
 			}
 			long n = 0;
-			Assert.AreEqual(n, out_Renamed.Length(), "output length must match");
+			Assert.AreEqual(n, out_Renamed.Length, "output length must match");
 			while (n <= MAX_VALUE - b1.Length)
 			{
 				out_Renamed.WriteBytes(b1, 0, b1.Length);
 				out_Renamed.Flush();
 				n += b1.Length;
-				Assert.AreEqual(n, out_Renamed.Length(), "output length must match");
+				Assert.AreEqual(n, out_Renamed.Length, "output length must match");
 			}
 			//System.out.println("after writing b1's, length = "+out.length()+" (MAX_VALUE="+MAX_VALUE+")");
 			int m = b2.Length;
@@ -97,7 +97,7 @@ namespace Lucene.Net.Store
 				out_Renamed.WriteBytes(b2, 0, m);
 				out_Renamed.Flush();
 				n += m;
-				Assert.AreEqual(n, out_Renamed.Length(), "output length must match");
+				Assert.AreEqual(n, out_Renamed.Length, "output length must match");
 			}
 			out_Renamed.Close();
 			// input part

Modified: incubator/lucene.net/trunk/test/core/Store/TestLockFactory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/TestLockFactory.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/TestLockFactory.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/TestLockFactory.cs Mon Mar 12 22:29:26 2012
@@ -80,9 +80,9 @@ namespace Lucene.Net.Store
 		public virtual void  TestRAMDirectoryNoLocking()
 		{
 			Directory dir = new RAMDirectory();
-			dir.SetLockFactory(NoLockFactory.GetNoLockFactory());
+			dir.SetLockFactory(NoLockFactory.Instance);
 			
-			Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(dir.GetLockFactory()), "RAMDirectory.setLockFactory
did not take");
+			Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(dir.LockFactory), "RAMDirectory.setLockFactory
did not take");
 			
 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
 			
@@ -113,7 +113,7 @@ namespace Lucene.Net.Store
 		{
 			Directory dir = new RAMDirectory();
 			
-			Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(dir.GetLockFactory()),
"RAMDirectory did not use correct LockFactory: got " + dir.GetLockFactory());
+			Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(dir.LockFactory), "RAMDirectory
did not use correct LockFactory: got " + dir.LockFactory);
 			
 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
 			
@@ -195,7 +195,7 @@ namespace Lucene.Net.Store
 			
 			NativeFSLockFactory f = new NativeFSLockFactory(AppSettings.Get("tempDir", System.IO.Path.GetTempPath()));
 			
-			f.SetLockPrefix("test");
+			f.LockPrefix = "test";
 			Lock l = f.MakeLock("commit");
 			Lock l2 = f.MakeLock("commit");
 			
@@ -226,10 +226,10 @@ namespace Lucene.Net.Store
 			// same directory, but locks are stored somewhere else. The prefix of the lock factory
should != null
 			Directory dir2 = FSDirectory.Open(new System.IO.DirectoryInfo(fdir1.FullName), new NativeFSLockFactory(fdir2));
 			
-			System.String prefix1 = dir1.GetLockFactory().GetLockPrefix();
+			System.String prefix1 = dir1.LockFactory.LockPrefix;
 			Assert.IsNull(prefix1, "Lock prefix for lockDir same as directory should be null");
 			
-			System.String prefix2 = dir2.GetLockFactory().GetLockPrefix();
+			System.String prefix2 = dir2.LockFactory.LockPrefix;
 			Assert.IsNotNull(prefix2, "Lock prefix for lockDir outside of directory should be not
null");
 			
 			_TestUtil.RmDir(fdir1);
@@ -246,7 +246,7 @@ namespace Lucene.Net.Store
 			System.IO.DirectoryInfo dirName = _TestUtil.GetTempDir("TestLockFactory.10");
 			Directory dir = FSDirectory.Open(dirName);
 			
-			System.String prefix = dir.GetLockFactory().GetLockPrefix();
+			System.String prefix = dir.LockFactory.LockPrefix;
 			
 			Assert.IsTrue(null == prefix, "Default lock prefix should be null");
 			
@@ -438,14 +438,17 @@ namespace Lucene.Net.Store
 			public bool lockPrefixSet;
 			public System.Collections.IDictionary locksCreated = System.Collections.Hashtable.Synchronized(new
System.Collections.Hashtable(new System.Collections.Hashtable()));
 			public int makeLockCount = 0;
-			
-			public override void  SetLockPrefix(System.String lockPrefix)
-			{
-				base.SetLockPrefix(lockPrefix);
-				lockPrefixSet = true;
-			}
-			
-			public override Lock MakeLock(System.String lockName)
+
+		    public override string LockPrefix
+		    {
+		        set
+		        {
+		            base.LockPrefix = value;
+		            lockPrefixSet = true;
+		        }
+		    }
+
+		    public override Lock MakeLock(System.String lockName)
 			{
 				lock (this)
 				{

Modified: incubator/lucene.net/trunk/test/core/Store/TestRAMDirectory.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Store/TestRAMDirectory.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Store/TestRAMDirectory.cs (original)
+++ incubator/lucene.net/trunk/test/core/Store/TestRAMDirectory.cs Mon Mar 12 22:29:26 2012
@@ -126,7 +126,7 @@ namespace Lucene.Net.Store
 			
 			// open reader to test document count
 			IndexReader reader = IndexReader.Open(ramDir, true);
-			Assert.AreEqual(docsToAdd, reader.NumDocs());
+			Assert.AreEqual(docsToAdd, reader.NumDocs);
 			
 			// open search zo check if all doc's are there
 			IndexSearcher searcher = new IndexSearcher(reader);

Modified: incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs (original)
+++ incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs Mon Mar 12 22:29:26 2012
@@ -158,20 +158,20 @@ namespace Lucene.Net.Support
 
             writer.DeleteDocuments(new Lucene.Net.Index.Term("TEST", "mytest"));
 
-            Assert.IsFalse(reader.IsCurrent());
+            Assert.IsFalse(reader.IsCurrent);
 
             int resCount1 = new IndexSearcher(reader).Search(new TermQuery(new Term("TEST",
"mytest")),100).TotalHits; 
             Assert.AreEqual(1, resCount1);
 
             writer.Commit();
 
-            Assert.IsFalse(reader.IsCurrent());
+            Assert.IsFalse(reader.IsCurrent);
 
             int resCount2 = new IndexSearcher(reader).Search(new TermQuery(new Term("TEST",
"mytest")),100).TotalHits;
             Assert.AreEqual(1, resCount2, "Reopen not invoked yet, resultCount must still
be 1.");
 
             reader = reader.Reopen();
-            Assert.IsTrue(reader.IsCurrent());
+            Assert.IsTrue(reader.IsCurrent);
 
             int resCount3 = new IndexSearcher(reader).Search(new TermQuery(new Term("TEST",
"mytest")), 100).TotalHits;
             Assert.AreEqual(0, resCount3, "After reopen, resultCount must be 0.");

Modified: incubator/lucene.net/trunk/test/core/TestDemo.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/TestDemo.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/TestDemo.cs (original)
+++ incubator/lucene.net/trunk/test/core/TestDemo.cs Mon Mar 12 22:29:26 2012
@@ -74,7 +74,7 @@ namespace Lucene.Net
 			// Iterate through the results:
 			for (int i = 0; i < hits.Length; i++)
 			{
-				Document hitDoc = isearcher.Doc(hits[i].doc);
+				Document hitDoc = isearcher.Doc(hits[i].Doc);
 				Assert.AreEqual(hitDoc.Get("fieldname"), "This is the text to be indexed.");
 			}
 			isearcher.Close();

Modified: incubator/lucene.net/trunk/test/core/TestSearch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/TestSearch.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/TestSearch.cs (original)
+++ incubator/lucene.net/trunk/test/core/TestSearch.cs Mon Mar 12 22:29:26 2012
@@ -79,7 +79,7 @@ namespace Lucene.Net
 			Analyzer analyzer = new SimpleAnalyzer();
 			IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			
-			writer.SetUseCompoundFile(useCompoundFile);
+			writer.UseCompoundFile = useCompoundFile;
 			
 			System.String[] docs = new System.String[]{"a b c d e", "a b c d e a b c d e", "a b c
d e f g h i j", "a c e", "e c a", "a c e a c e", "a c e a b c"};
 			for (int j = 0; j < docs.Length; j++)
@@ -96,7 +96,7 @@ namespace Lucene.Net
 			ScoreDoc[] hits = null;
 			
 			QueryParser parser = new QueryParser(Util.Version.LUCENE_CURRENT, "contents", analyzer);
-			parser.SetPhraseSlop(4);
+			parser.PhraseSlop = 4;
 			for (int j = 0; j < queries.Length; j++)
 			{
 				Query query = parser.Parse(queries[j]);
@@ -112,8 +112,8 @@ namespace Lucene.Net
 				out_Renamed.WriteLine(hits.Length + " total results");
 				for (int i = 0; i < hits.Length && i < 10; i++)
 				{
-					Document d = searcher.Doc(hits[i].doc);
-					out_Renamed.WriteLine(i + " " + hits[i].score + " " + d.Get("contents"));
+					Document d = searcher.Doc(hits[i].Doc);
+					out_Renamed.WriteLine(i + " " + hits[i].Score + " " + d.Get("contents"));
 				}
 			}
 			searcher.Close();

Modified: incubator/lucene.net/trunk/test/core/TestSearchForDuplicates.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/TestSearchForDuplicates.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/TestSearchForDuplicates.cs (original)
+++ incubator/lucene.net/trunk/test/core/TestSearchForDuplicates.cs Mon Mar 12 22:29:26 2012
@@ -88,7 +88,7 @@ namespace Lucene.Net
 			Analyzer analyzer = new SimpleAnalyzer();
 			IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
 			
-			writer.SetUseCompoundFile(useCompoundFiles);
+			writer.UseCompoundFile = useCompoundFiles;
 			
 			int MAX_DOCS = 225;
 			
@@ -139,7 +139,7 @@ namespace Lucene.Net
 			{
 				if (i < 10 || (i > 94 && i < 105))
 				{
-					Document d = searcher.Doc(hits[i].doc);
+					Document d = searcher.Doc(hits[i].Doc);
 					out_Renamed.WriteLine(i + " " + d.Get(ID_FIELD));
 				}
 			}
@@ -152,7 +152,7 @@ namespace Lucene.Net
 			{
 				if (i < 10 || (i > 94 && i < 105))
 				{
-					Document d = searcher.Doc(hits[i].doc);
+					Document d = searcher.Doc(hits[i].Doc);
 					Assert.AreEqual(System.Convert.ToString(i), d.Get(ID_FIELD), "check " + i);
 				}
 			}

Modified: incubator/lucene.net/trunk/test/core/Util/TestAttributeSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Util/TestAttributeSource.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Util/TestAttributeSource.cs (original)
+++ incubator/lucene.net/trunk/test/core/Util/TestAttributeSource.cs Mon Mar 12 22:29:26 2012
@@ -20,8 +20,8 @@ using System;
 using NUnit.Framework;
 
 using Token = Lucene.Net.Analysis.Token;
-using FlagsAttribute = Lucene.Net.Analysis.Tokenattributes.FlagsAttribute;
 using Lucene.Net.Analysis.Tokenattributes;
+using FlagsAttribute = Lucene.Net.Analysis.Tokenattributes.FlagsAttribute;
 
 namespace Lucene.Net.Util
 {
@@ -66,12 +66,12 @@ namespace Lucene.Net.Util
             typeAtt = src2.AddAttribute<TypeAttribute>();
             FlagsAttribute flagsAtt = src2.AddAttribute<FlagsAttribute>();
             termAtt = src2.AddAttribute<TermAttribute>();
-            flagsAtt.SetFlags(12345);
+            flagsAtt.Flags = 12345;
 
             src2.RestoreState(state);
             Assert.AreEqual("TestTerm", termAtt.Term());
             Assert.AreEqual("TestType", typeAtt.Type());
-            Assert.AreEqual(12345, flagsAtt.GetFlags(), "FlagsAttribute should not be touched");
+            Assert.AreEqual(12345, flagsAtt.Flags, "FlagsAttribute should not be touched");
 
             // init a third instance missing one Attribute
             AttributeSource src3 = new AttributeSource();

Modified: incubator/lucene.net/trunk/test/core/Util/TestFieldCacheSanityChecker.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Util/TestFieldCacheSanityChecker.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Util/TestFieldCacheSanityChecker.cs (original)
+++ incubator/lucene.net/trunk/test/core/Util/TestFieldCacheSanityChecker.cs Mon Mar 12 22:29:26
2012
@@ -147,7 +147,7 @@ namespace Lucene.Net.Util
 			Insanity[] insanity = FieldCacheSanityChecker.CheckSanity(cache.GetCacheEntries());
 			
 			Assert.AreEqual(1, insanity.Length, "wrong number of cache errors");
-			Assert.AreEqual(InsanityType.VALUEMISMATCH, insanity[0].GetType(), "wrong type of cache
error");
+			Assert.AreEqual(InsanityType.VALUEMISMATCH, insanity[0].Type, "wrong type of cache error");
 			Assert.AreEqual(2, insanity[0].GetCacheEntries().Length, "wrong number of entries in cache
error");
 			
 			// we expect bad things, don't let tearDown complain about them
@@ -176,7 +176,7 @@ namespace Lucene.Net.Util
 			Insanity[] insanity = FieldCacheSanityChecker.CheckSanity(cache.GetCacheEntries());
 			
 			Assert.AreEqual(1, insanity.Length, "wrong number of cache errors");
-			Assert.AreEqual(InsanityType.SUBREADER, insanity[0].GetType(), "wrong type of cache error");
+			Assert.AreEqual(InsanityType.SUBREADER, insanity[0].Type, "wrong type of cache error");
 			Assert.AreEqual(3, insanity[0].GetCacheEntries().Length, "wrong number of entries in cache
error");
 			
 			// we expect bad things, don't let tearDown complain about them

Modified: incubator/lucene.net/trunk/test/core/Util/TestSortedVIntList.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Util/TestSortedVIntList.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Util/TestSortedVIntList.cs (original)
+++ incubator/lucene.net/trunk/test/core/Util/TestSortedVIntList.cs Mon Mar 12 22:29:26 2012
@@ -48,8 +48,8 @@ namespace Lucene.Net.Util
 		
 		internal virtual void  TstVIntList(SortedVIntList vintList, int[] ints, int expectedByteSize)
 		{
-			Assert.AreEqual(ints.Length, vintList.Size(), "Size");
-			Assert.AreEqual(expectedByteSize, vintList.GetByteSize(), "Byte size");
+			Assert.AreEqual(ints.Length, vintList.Size, "Size");
+			Assert.AreEqual(expectedByteSize, vintList.ByteSize, "Byte size");
 			TstIterator(vintList, ints);
 		}
 		

Modified: incubator/lucene.net/trunk/test/core/Util/_TestUtil.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Util/_TestUtil.cs?rev=1299911&r1=1299910&r2=1299911&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Util/_TestUtil.cs (original)
+++ incubator/lucene.net/trunk/test/core/Util/_TestUtil.cs Mon Mar 12 22:29:26 2012
@@ -100,7 +100,7 @@ namespace Lucene.Net.Util
 		
 		public static void  SyncConcurrentMerges(IndexWriter writer)
 		{
-			SyncConcurrentMerges(writer.GetMergeScheduler());
+			SyncConcurrentMerges(writer.MergeScheduler);
 		}
 		
 		public static void  SyncConcurrentMerges(MergeScheduler ms)



Mime
View raw message