[43/50] [abbrv] lucenenet git commit: Lucene.Net.Suggest refactor: Changed all public fields to auto-implemented properties

Tue, 31 Jan 2017 09:56:34 -0800 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1647a703/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
----------------------------------------------------------------------
diff --git 
a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs 
b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
index 97e820e..9690713 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
@@ -53,8 +53,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 string addRandomEdit = AddRandomEdit("foo bar boo", 
FuzzySuggester.DEFAULT_NON_FUZZY_PREFIX);
                 IList<Lookup.LookupResult> results = 
suggester.DoLookup(TestUtil.StringToCharSequence(addRandomEdit, 
Random()).ToString(), false, 2);
                 assertEquals(addRandomEdit, 1, results.size());
-                assertEquals("foo bar boo far", 
results.ElementAt(0).key.toString());
-                assertEquals(12, results.ElementAt(0).value, 0.01F);
+                assertEquals("foo bar boo far", 
results.ElementAt(0).Key.toString());
+                assertEquals(12, results.ElementAt(0).Value, 0.01F);
             }
         }
 
@@ -78,8 +78,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 string addRandomEdit = AddRandomEdit("фуу бар буу", 
0);
                 IList<Lookup.LookupResult> results = 
suggester.DoLookup(TestUtil.StringToCharSequence(addRandomEdit, 
Random()).ToString(), false, 2);
                 assertEquals(addRandomEdit, 1, results.size());
-                assertEquals("фуу бар буу фар", 
results.ElementAt(0).key.toString());
-                assertEquals(12, results.ElementAt(0).value, 0.01F);
+                assertEquals("фуу бар буу фар", 
results.ElementAt(0).Key.toString());
+                assertEquals(12, results.ElementAt(0).Value, 0.01F);
             }
         }
 
@@ -99,63 +99,63 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             IList<Lookup.LookupResult> results = 
suggester.DoLookup(TestUtil.StringToCharSequence("bariar", 
Random()).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
 
             results = 
suggester.DoLookup(TestUtil.StringToCharSequence("barbr", Random()).ToString(), 
false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
 
             results = 
suggester.DoLookup(TestUtil.StringToCharSequence("barbara", 
Random()).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbara", results.ElementAt(0).key.toString());
-            assertEquals(6, results.ElementAt(0).value, 0.01F);
+            assertEquals("barbara", results.ElementAt(0).Key.toString());
+            assertEquals(6, results.ElementAt(0).Value, 0.01F);
 
             results = 
suggester.DoLookup(TestUtil.StringToCharSequence("barbar", 
Random()).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
-            assertEquals("barbara", results.ElementAt(1).key.toString());
-            assertEquals(6, results.ElementAt(1).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
+            assertEquals("barbara", results.ElementAt(1).Key.toString());
+            assertEquals(6, results.ElementAt(1).Value, 0.01F);
 
             results = 
suggester.DoLookup(TestUtil.StringToCharSequence("barbaa", 
Random()).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
-            assertEquals("barbara", results.ElementAt(1).key.toString());
-            assertEquals(6, results.ElementAt(1).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
+            assertEquals("barbara", results.ElementAt(1).Key.toString());
+            assertEquals(6, results.ElementAt(1).Value, 0.01F);
 
             // top N of 2, but only foo is available
             results = suggester.DoLookup(TestUtil.StringToCharSequence("f", 
Random()).ToString(), false, 2);
             assertEquals(1, results.size());
-            assertEquals("foo", results.ElementAt(0).key.toString());
-            assertEquals(50, results.ElementAt(0).value, 0.01F);
+            assertEquals("foo", results.ElementAt(0).Key.toString());
+            assertEquals(50, results.ElementAt(0).Value, 0.01F);
 
             // top N of 1 for 'bar': we return this even though
             // barbar is higher because exactFirst is enabled:
             results = suggester.DoLookup(TestUtil.StringToCharSequence("bar", 
Random()).ToString(), false, 1);
             assertEquals(1, results.size());
-            assertEquals("bar", results.ElementAt(0).key.toString());
-            assertEquals(10, results.ElementAt(0).value, 0.01F);
+            assertEquals("bar", results.ElementAt(0).Key.toString());
+            assertEquals(10, results.ElementAt(0).Value, 0.01F);
 
             // top N Of 2 for 'b'
             results = suggester.DoLookup(TestUtil.StringToCharSequence("b", 
Random()).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
-            assertEquals("bar", results.ElementAt(1).key.toString());
-            assertEquals(10, results.ElementAt(1).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
+            assertEquals("bar", results.ElementAt(1).Key.toString());
+            assertEquals(10, results.ElementAt(1).Value, 0.01F);
 
             // top N of 3 for 'ba'
             results = suggester.DoLookup(TestUtil.StringToCharSequence("ba", 
Random()).ToString(), false, 3);
             assertEquals(3, results.size());
-            assertEquals("barbar", results.ElementAt(0).key.toString());
-            assertEquals(12, results.ElementAt(0).value, 0.01F);
-            assertEquals("bar", results.ElementAt(1).key.toString());
-            assertEquals(10, results.ElementAt(1).value, 0.01F);
-            assertEquals("barbara", results.ElementAt(2).key.toString());
-            assertEquals(6, results.ElementAt(2).value, 0.01F);
+            assertEquals("barbar", results.ElementAt(0).Key.toString());
+            assertEquals(12, results.ElementAt(0).Value, 0.01F);
+            assertEquals("bar", results.ElementAt(1).Key.toString());
+            assertEquals(10, results.ElementAt(1).Value, 0.01F);
+            assertEquals("barbara", results.ElementAt(2).Key.toString());
+            assertEquals(6, results.ElementAt(2).Value, 0.01F);
         }
 
         /**
@@ -175,20 +175,20 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             IList<Lookup.LookupResult> results = 
suggester.DoLookup(TestUtil.StringToCharSequence("the ghost of chris", 
Random()).ToString(), false, 1);
             assertEquals(1, results.size());
-            assertEquals("the ghost of christmas past", 
results.ElementAt(0).key.toString());
-            assertEquals(50, results.ElementAt(0).value, 0.01F);
+            assertEquals("the ghost of christmas past", 
results.ElementAt(0).Key.toString());
+            assertEquals(50, results.ElementAt(0).Value, 0.01F);
 
             // omit the 'the' since its a stopword, its suggested anyway
             results = suggester.DoLookup(TestUtil.StringToCharSequence("ghost 
of chris", Random()).ToString(), false, 1);
             assertEquals(1, results.size());
-            assertEquals("the ghost of christmas past", 
results.ElementAt(0).key.toString());
-            assertEquals(50, results.ElementAt(0).value, 0.01F);
+            assertEquals("the ghost of christmas past", 
results.ElementAt(0).Key.toString());
+            assertEquals(50, results.ElementAt(0).Value, 0.01F);
 
             // omit the 'the' and 'of' since they are stopwords, its suggested 
anyway
             results = suggester.DoLookup(TestUtil.StringToCharSequence("ghost 
chris", Random()).ToString(), false, 1);
             assertEquals(1, results.size());
-            assertEquals("the ghost of christmas past", 
results.ElementAt(0).key.toString());
-            assertEquals(50, results.ElementAt(0).value, 0.01F);
+            assertEquals("the ghost of christmas past", 
results.ElementAt(0).Key.toString());
+            assertEquals(50, results.ElementAt(0).Value, 0.01F);
         }
 
         [Test]
@@ -214,7 +214,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             // With no PRESERVE_SEPS specified, "ab c" should also
             // complete to "abcd", which has higher weight so should
             // appear first:
-            assertEquals("abcd", r.ElementAt(0).key.toString());
+            assertEquals("abcd", r.ElementAt(0).Key.toString());
         }
         internal class TestGraphDupsTokenStreamComponents : 
Analyzer.TokenStreamComponents
         {
@@ -298,10 +298,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 Console.WriteLine("Results: " + results);
             }
             assertEquals(2, results.size());
-            assertEquals("wifi network is slow", results.ElementAt(0).key);
-            assertEquals(50, results.ElementAt(0).value);
-            assertEquals("wi fi network is fast", results.ElementAt(1).key);
-            assertEquals(10, results.ElementAt(1).value);
+            assertEquals("wifi network is slow", results.ElementAt(0).Key);
+            assertEquals(50, results.ElementAt(0).Value);
+            assertEquals("wi fi network is fast", results.ElementAt(1).Key);
+            assertEquals(10, results.ElementAt(1).Value);
         }
 
         [Test]
@@ -502,23 +502,23 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                 assertEquals(Math.Min(topN, 4), results.size());
 
-                assertEquals("x y", results.ElementAt(0).key);
-                assertEquals(1, results.ElementAt(0).value);
+                assertEquals("x y", results.ElementAt(0).Key);
+                assertEquals(1, results.ElementAt(0).Value);
 
                 if (topN > 1)
                 {
-                    assertEquals("z z z", results.ElementAt(1).key);
-                    assertEquals(20, results.ElementAt(1).value);
+                    assertEquals("z z z", results.ElementAt(1).Key);
+                    assertEquals(20, results.ElementAt(1).Value);
 
                     if (topN > 2)
                     {
-                        assertEquals("x y z", results.ElementAt(2).key);
-                        assertEquals(3, results.ElementAt(2).value);
+                        assertEquals("x y z", results.ElementAt(2).Key);
+                        assertEquals(3, results.ElementAt(2).Value);
 
                         if (topN > 3)
                         {
-                            assertEquals("x", results.ElementAt(3).key);
-                            assertEquals(2, results.ElementAt(3).value);
+                            assertEquals("x", results.ElementAt(3).Key);
+                            assertEquals(2, results.ElementAt(3).Value);
                         }
                     }
                 }
@@ -545,23 +545,23 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                 assertEquals(Math.Min(topN, 4), results.size());
 
-                assertEquals("z z z", results.ElementAt(0).key);
-                assertEquals(20, results.ElementAt(0).value);
+                assertEquals("z z z", results.ElementAt(0).Key);
+                assertEquals(20, results.ElementAt(0).Value);
 
                 if (topN > 1)
                 {
-                    assertEquals("x y z", results.ElementAt(1).key);
-                    assertEquals(3, results.ElementAt(1).value);
+                    assertEquals("x y z", results.ElementAt(1).Key);
+                    assertEquals(3, results.ElementAt(1).Value);
 
                     if (topN > 2)
                     {
-                        assertEquals("x", results.ElementAt(2).key);
-                        assertEquals(2, results.ElementAt(2).value);
+                        assertEquals("x", results.ElementAt(2).Key);
+                        assertEquals(2, results.ElementAt(2).Value);
 
                         if (topN > 3)
                         {
-                            assertEquals("x y", results.ElementAt(3).key);
-                            assertEquals(1, results.ElementAt(3).value);
+                            assertEquals("x y", results.ElementAt(3).Key);
+                            assertEquals(1, results.ElementAt(3).Value);
                         }
                     }
                 }
@@ -699,7 +699,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         {
             public int Compare(Lookup.LookupResult left, Lookup.LookupResult 
right)
             {
-                int cmp = ((float)right.value).CompareTo((float)left.value);
+                int cmp = ((float)right.Value).CompareTo((float)left.Value);
                 if (cmp == 0)
                 {
                     return left.CompareTo(right);
@@ -956,13 +956,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     Console.WriteLine("  expected:");
                     foreach (Lookup.LookupResult lr in matches)
                     {
-                        Console.WriteLine("    key=" + lr.key + " weight=" + 
lr.value);
+                        Console.WriteLine("    key=" + lr.Key + " weight=" + 
lr.Value);
                     }
 
                     Console.WriteLine("  actual:");
                     foreach (Lookup.LookupResult lr in r)
                     {
-                        Console.WriteLine("    key=" + lr.key + " weight=" + 
lr.value);
+                        Console.WriteLine("    key=" + lr.Key + " weight=" + 
lr.Value);
                     }
                 }
 
@@ -971,8 +971,8 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 for (int hit = 0; hit < r.size(); hit++)
                 {
                     //Console.WriteLine("  check hit " + hit);
-                    assertEquals(prefix + "  " + topN, 
matches.ElementAt(hit).key.toString(), r.ElementAt(hit).key.toString());
-                    assertEquals(matches.ElementAt(hit).value, 
r.ElementAt(hit).value, 0f);
+                    assertEquals(prefix + "  " + topN, 
matches.ElementAt(hit).Key.toString(), r.ElementAt(hit).Key.toString());
+                    assertEquals(matches.ElementAt(hit).Value, 
r.ElementAt(hit).Value, 0f);
                 }
             }
         }
@@ -994,10 +994,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             IList<Lookup.LookupResult> results = suggester.DoLookup("a", 
false, 5);
             assertEquals(2, results.size());
-            assertEquals(" a", results.ElementAt(0).key);
-            assertEquals(60, results.ElementAt(0).value);
-            assertEquals("a ", results.ElementAt(1).key);
-            assertEquals(50, results.ElementAt(1).value);
+            assertEquals(" a", results.ElementAt(0).Key);
+            assertEquals(60, results.ElementAt(0).Value);
+            assertEquals("a ", results.ElementAt(1).Key);
+            assertEquals(50, results.ElementAt(1).Value);
         }
 
         [Test]
@@ -1185,11 +1185,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 {
                     Lookup.LookupResult c0 = expected.ElementAt(ans);
                     Lookup.LookupResult c1 = actual.ElementAt(ans);
-                    assertEquals("expected " + c0.key +
-                                 " but got " + c1.key,
+                    assertEquals("expected " + c0.Key +
+                                 " but got " + c1.Key,
                                  0,
-                                 CHARSEQUENCE_COMPARER.Compare(c0.key, 
c1.key));
-                    assertEquals(c0.value, c1.value);
+                                 CHARSEQUENCE_COMPARER.Compare(c0.Key, 
c1.Key));
+                    assertEquals(c0.Value, c1.Value);
                 }
                 assertEquals(expected.size(), actual.size());
             }
@@ -1297,18 +1297,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             public int Compare(Lookup.LookupResult a, Lookup.LookupResult b)
             {
-                if (a.value > b.value)
+                if (a.Value > b.Value)
                 {
                     return -1;
                 }
-                else if (a.value < b.value)
+                else if (a.Value < b.Value)
                 {
                     return 1;
                 }
                 else
                 {
-                    int c = CHARSEQUENCE_COMPARER.Compare(a.key, b.key);
-                    Debug.Assert(c != 0, "term=" + a.key);
+                    int c = CHARSEQUENCE_COMPARER.Compare(a.Key, b.Key);
+                    Debug.Assert(c != 0, "term=" + a.Key);
                     return c;
                 }
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1647a703/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
----------------------------------------------------------------------
diff --git 
a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs 
b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
index 9b1960d..64b7511 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/TestFreeTextSuggester.cs
@@ -337,18 +337,18 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         {
             public int Compare(Lookup.LookupResult a, Lookup.LookupResult b)
             {
-                if (a.value > b.value)
+                if (a.Value > b.Value)
                 {
                     return -1;
                 }
-                else if (a.value < b.value)
+                else if (a.Value < b.Value)
                 {
                     return 1;
                 }
                 else
                 {
                     // Tie break by UTF16 sort order:
-                    return ((string)a.key).CompareToOrdinal((string)b.key);
+                    return ((string)a.Key).CompareToOrdinal((string)b.Key);
                 }
             }
         }
@@ -682,7 +682,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                                 tmp.Add(lr);
                                 if (VERBOSE)
                                 {
-                                    Console.WriteLine("      add tmp key='" + 
lr.key + "' score=" + lr.value);
+                                    Console.WriteLine("      add tmp key='" + 
lr.Key + "' score=" + lr.Value);
                                 }
                             }
                         }
@@ -698,7 +698,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     }
                     foreach (Lookup.LookupResult result in tmp)
                     {
-                        string key = result.key.toString();
+                        string key = result.Key.toString();
                         int idx = key.LastIndexOf(' ');
                         string lastToken;
                         if (idx != -1)
@@ -715,7 +715,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                             expected.Add(result);
                             if (VERBOSE)
                             {
-                                Console.WriteLine("      keep key='" + 
result.key + "' score=" + result.value);
+                                Console.WriteLine("      keep key='" + 
result.Key + "' score=" + result.Value);
                             }
                         }
                     }
@@ -763,9 +763,9 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             foreach (Lookup.LookupResult result in results)
             {
                 b.Append(' ');
-                b.Append(result.key);
+                b.Append(result.Key);
                 b.Append('/');
-                b.AppendFormat(CultureInfo.InvariantCulture, "{0:0.00}", 
((double)result.value) / long.MaxValue);
+                b.AppendFormat(CultureInfo.InvariantCulture, "{0:0.00}", 
((double)result.Value) / long.MaxValue);
             }
             return b.toString().Trim();
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1647a703/src/Lucene.Net.Tests.Suggest/Suggest/Fst/FSTCompletionTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Fst/FSTCompletionTest.cs 
b/src/Lucene.Net.Tests.Suggest/Suggest/Fst/FSTCompletionTest.cs
index 00c4fbc..69ab50b 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Fst/FSTCompletionTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Fst/FSTCompletionTest.cs
@@ -214,13 +214,13 @@ namespace Lucene.Net.Search.Suggest.Fst
             foreach (Input tf in input)
             {
                 assertNotNull("Not found: " + tf.term.toString(), 
lookup.Get(TestUtil.BytesToCharSequence(tf.term, Random()).ToString()));
-                assertEquals(tf.term.Utf8ToString(), 
lookup.DoLookup(TestUtil.BytesToCharSequence(tf.term, Random()).ToString(), 
true, 1)[0].key.toString());
+                assertEquals(tf.term.Utf8ToString(), 
lookup.DoLookup(TestUtil.BytesToCharSequence(tf.term, Random()).ToString(), 
true, 1)[0].Key.toString());
             }
 
             IList<Lookup.LookupResult> result = 
lookup.DoLookup(StringToCharSequence("wit").ToString(), true, 5);
             assertEquals(5, result.size());
-            assertTrue(result[0].key.toString().equals("wit"));  // exact 
match.
-            assertTrue(result[1].key.toString().equals("with")); // highest 
count.
+            assertTrue(result[0].Key.toString().equals("wit"));  // exact 
match.
+            assertTrue(result[1].Key.toString().equals("with")); // highest 
count.
         }
 
         [Test]
@@ -252,7 +252,7 @@ namespace Lucene.Net.Search.Suggest.Fst
                     String prefix = term.Substring(0, i - 0);
                     foreach (Lookup.LookupResult lr in 
lookup.DoLookup(StringToCharSequence(prefix).ToString(), true, 10))
                     {
-                        assertTrue(lr.key.toString().StartsWith(prefix));
+                        assertTrue(lr.Key.toString().StartsWith(prefix));
                     }
                 }
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1647a703/src/Lucene.Net.Tests.Suggest/Suggest/Fst/WFSTCompletionTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Fst/WFSTCompletionTest.cs 
b/src/Lucene.Net.Tests.Suggest/Suggest/Fst/WFSTCompletionTest.cs
index 8f8b916..a72d456 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Fst/WFSTCompletionTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Fst/WFSTCompletionTest.cs
@@ -43,38 +43,38 @@ namespace Lucene.Net.Search.Suggest.Fst
             // top N of 2, but only foo is available
             IList<Lookup.LookupResult> results = 
suggester.DoLookup(TestUtil.StringToCharSequence("f", random).ToString(), 
false, 2);
             assertEquals(1, results.size());
-            assertEquals("foo", results[0].key.toString());
-            assertEquals(50, results[0].value, 0.01F);
+            assertEquals("foo", results[0].Key.toString());
+            assertEquals(50, results[0].Value, 0.01F);
 
             // make sure we don't get a dup exact suggestion:
             results = suggester.DoLookup(TestUtil.StringToCharSequence("foo", 
random).ToString(), false, 2);
             assertEquals(1, results.size());
-            assertEquals("foo", results[0].key.toString());
-            assertEquals(50, results[0].value, 0.01F);
+            assertEquals("foo", results[0].Key.toString());
+            assertEquals(50, results[0].Value, 0.01F);
 
             // top N of 1 for 'bar': we return this even though barbar is 
higher
             results = suggester.DoLookup(TestUtil.StringToCharSequence("bar", 
random).ToString(), false, 1);
             assertEquals(1, results.size());
-            assertEquals("bar", results[0].key.toString());
-            assertEquals(10, results[0].value, 0.01F);
+            assertEquals("bar", results[0].Key.toString());
+            assertEquals(10, results[0].Value, 0.01F);
 
             // top N Of 2 for 'b'
             results = suggester.DoLookup(TestUtil.StringToCharSequence("b", 
random).ToString(), false, 2);
             assertEquals(2, results.size());
-            assertEquals("barbar", results[0].key.toString());
-            assertEquals(12, results[0].value, 0.01F);
-            assertEquals("bar", results[1].key.toString());
-            assertEquals(10, results[1].value, 0.01F);
+            assertEquals("barbar", results[0].Key.toString());
+            assertEquals(12, results[0].Value, 0.01F);
+            assertEquals("bar", results[1].Key.toString());
+            assertEquals(10, results[1].Value, 0.01F);
 
             // top N of 3 for 'ba'
             results = suggester.DoLookup(TestUtil.StringToCharSequence("ba", 
random).ToString(), false, 3);
             assertEquals(3, results.size());
-            assertEquals("barbar", results[0].key.toString());
-            assertEquals(12, results[0].value, 0.01F);
-            assertEquals("bar", results[1].key.toString());
-            assertEquals(10, results[1].value, 0.01F);
-            assertEquals("barbara", results[2].key.toString());
-            assertEquals(6, results[2].value, 0.01F);
+            assertEquals("barbar", results[0].Key.toString());
+            assertEquals(12, results[0].Value, 0.01F);
+            assertEquals("bar", results[1].Key.toString());
+            assertEquals(10, results[1].Value, 0.01F);
+            assertEquals("barbara", results[2].Key.toString());
+            assertEquals(6, results[2].Value, 0.01F);
         }
 
         [Test]
@@ -94,13 +94,13 @@ namespace Lucene.Net.Search.Suggest.Fst
 
                 assertEquals(Math.Min(topN, 2), results.size());
 
-                assertEquals("x", results[0].key);
-                assertEquals(2, results[0].value);
+                assertEquals("x", results[0].Key);
+                assertEquals(2, results[0].Value);
 
                 if (topN > 1)
                 {
-                    assertEquals("x y", results[1].key);
-                    assertEquals(20, results[1].value);
+                    assertEquals("x y", results[1].Key);
+                    assertEquals(20, results[1].Value);
                 }
             }
         }
@@ -122,13 +122,13 @@ namespace Lucene.Net.Search.Suggest.Fst
 
                 assertEquals(Math.Min(topN, 2), results.size());
 
-                assertEquals("x y", results[0].key);
-                assertEquals(20, results[0].value);
+                assertEquals("x y", results[0].Key);
+                assertEquals(20, results[0].Value);
 
                 if (topN > 1)
                 {
-                    assertEquals("x", results[1].key);
-                    assertEquals(2, results[1].value);
+                    assertEquals("x", results[1].Key);
+                    assertEquals(2, results[1].Value);
                 }
             }
         }
@@ -203,8 +203,8 @@ namespace Lucene.Net.Search.Suggest.Fst
                 for (int hit = 0; hit < r.size(); hit++)
                 {
                     //System.out.println("  check hit " + hit);
-                    assertEquals(matches[hit].key.toString(), 
r[hit].key.toString());
-                    assertEquals(matches[hit].value, r[hit].value, 0f);
+                    assertEquals(matches[hit].Key.toString(), 
r[hit].Key.toString());
+                    assertEquals(matches[hit].Value, r[hit].Value, 0f);
                 }
             }
         }
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         {
             public int Compare(Lookup.LookupResult left, Lookup.LookupResult 
right)
             {
-                int cmp = ((float)right.value).CompareTo((float)left.value);
+                int cmp = ((float)right.Value).CompareTo((float)left.Value);
                 if (cmp == 0)
                 {
                     return left.CompareTo(right);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1647a703/src/Lucene.Net.Tests.Suggest/Suggest/PersistenceTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/PersistenceTest.cs 
b/src/Lucene.Net.Tests.Suggest/Suggest/PersistenceTest.cs
index f6af6bf..f90972b 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/PersistenceTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/PersistenceTest.cs
@@ -91,16 +91,16 @@ namespace Lucene.Net.Search.Suggest
                 IList<Lookup.LookupResult> list = 
lookup.DoLookup(TestUtil.BytesToCharSequence(k.term, random).ToString(), false, 
1);
                 assertEquals(1, list.size());
                 Lookup.LookupResult lookupResult = list[0];
-                assertNotNull(k.term.Utf8ToString(), lookupResult.key);
+                assertNotNull(k.term.Utf8ToString(), lookupResult.Key);
 
                 if (supportsExactWeights)
                 {
-                    assertEquals(k.term.Utf8ToString(), k.v, 
lookupResult.value);
+                    assertEquals(k.term.Utf8ToString(), k.v, 
lookupResult.Value);
                 }
                 else
                 {
-                    assertTrue(lookupResult.value + ">=" + previous, 
lookupResult.value >= previous);
-                    previous = lookupResult.value;
+                    assertTrue(lookupResult.Value + ">=" + previous, 
lookupResult.Value >= previous);
+                    previous = lookupResult.Value;
                 }
             }
         }

Reply via email to