public virtual void DoRandom(int iter, bool ignoreCase)
{
CharArrayMap<int?> map = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 1, ignoreCase);
HashMap<string, int?> hmap = new HashMap<string, int?>();
char[] key;
for (int i = 0; i < iter; i++)
{
int len = Random().Next(5);
key = new char[len];
for (int j = 0; j < key.Length; j++)
{
key[j] = (char)Random().Next(127);
}
string keyStr = new string(key);
string hmapKey = ignoreCase ? keyStr.ToLower() : keyStr;
int val = Random().Next();
object o1 = map.Put(key, val);
object o2 = hmap.Put(hmapKey, val);
assertEquals(o1, o2);
// add it again with the string method
assertEquals(val, map.Put(keyStr, val));
assertEquals(val, map.Get(key, 0, key.Length));
assertEquals(val, map.Get(key));
assertEquals(val, map.Get(keyStr));
assertEquals(hmap.Count, map.size());
}
}
public virtual void doRandom(int iter, bool ignoreCase)
{
CharArrayMap<int?> map = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 1, ignoreCase);
Dictionary<string, int?> hmap = new Dictionary<string, int?>();
char[] key;
for (int i = 0; i < iter; i++)
{
int len = random().Next(5);
key = new char[len];
for (int j = 0; j < key.Length; j++)
{
key[j] = (char)random().Next(127);
}
string keyStr = new string(key);
string hmapKey = ignoreCase ? keyStr.ToLower(Locale.ROOT) : keyStr;
int val = random().Next();
object o1 = map.put(key, val);
object o2 = hmap[hmapKey].Value = val;
assertEquals(o1,o2);
// add it again with the string method
assertEquals(val, map.put(keyStr,val).intValue());
assertEquals(val, map.get(key,0,key.Length).intValue());
assertEquals(val, map.get(key).intValue());
assertEquals(val, map.get(keyStr).intValue());
assertEquals(hmap.Count, map.size());
}
}
public DutchAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable)
: this(matchVersion, stopwords, stemExclusionTable,
#pragma warning disable 612, 618
matchVersion.OnOrAfter(LuceneVersion.LUCENE_36) ?
#pragma warning restore 612, 618
DefaultSetHolder.DEFAULT_STEM_DICT : CharArrayMap <string> .EmptyMap())
{
// historically, this ctor never the stem dict!!!!!
// so we populate it only for >= 3.6
}
private static CharArrayMap <string> LoadDefaultStemDict() // LUCENENET: Avoid static constructors (see https://github.com/apache/lucenenet/pull/224#issuecomment-469284006)
{
#pragma warning disable 612, 618
var DEFAULT_STEM_DICT = new CharArrayMap <string>(LuceneVersion.LUCENE_CURRENT, 4, false);
#pragma warning restore 612, 618
DEFAULT_STEM_DICT.Put("fiets", "fiets"); //otherwise fiet
DEFAULT_STEM_DICT.Put("bromfiets", "bromfiets"); //otherwise bromfiet
DEFAULT_STEM_DICT.Put("ei", "eier");
DEFAULT_STEM_DICT.Put("kind", "kinder");
return(DEFAULT_STEM_DICT);
}
public object Create(Random random)
{
int num = random.nextInt(10);
CharArrayMap <string> map = new CharArrayMap <string>(TEST_VERSION_CURRENT, num, random.nextBoolean());
for (int i = 0; i < num; i++)
{
// TODO: make nastier
map.Put(TestUtil.RandomSimpleString(random), TestUtil.RandomSimpleString(random));
}
return(map);
}
public virtual void testToString()
{
CharArrayMap <int?> cm = new CharArrayMap <int?>(TEST_VERSION_CURRENT, Collections.singletonMap("test", 1), false);
assertEquals("[test]", cm.Keys.ToString());
assertEquals("[1]", cm.values().ToString());
assertEquals("[test=1]", cm.entrySet().ToString());
assertEquals("{test=1}", cm.ToString());
cm.put("test2", 2);
assertTrue(cm.Keys.ToString().Contains(", "));
assertTrue(cm.values().ToString().Contains(", "));
assertTrue(cm.entrySet().ToString().Contains(", "));
assertTrue(cm.ToString().Contains(", "));
}
/// <summary>
/// Reads a stem dictionary. Each line contains:
/// <code>word<b>\t</b>stem</code>
/// (i.e. two tab separated words)
/// </summary>
/// <returns> stem dictionary that overrules the stemming algorithm </returns>
/// <exception cref="IOException"> If there is a low-level I/O error. </exception>
public static CharArrayMap <string> GetStemDict(TextReader reader, CharArrayMap <string> result)
{
try
{
string line;
while ((line = reader.ReadLine()) != null)
{
string[] wordstem = line.Split(new char[] { '\t' }, 2);
result.Put(wordstem[0], wordstem[1]);
}
}
finally
{
IOUtils.Dispose(reader);
}
return(result);
}
static DefaultSetHolder()
{
try
{
DEFAULT_STOP_SET = WordlistLoader.getSnowballWordSet(IOUtils.getDecodingReader(typeof(SnowballFilter), DEFAULT_STOPWORD_FILE, StandardCharsets.UTF_8), Version.LUCENE_CURRENT);
}
catch (IOException)
{
// default set should always be present as it is part of the
// distribution (JAR)
throw new Exception("Unable to load default stopword set");
}
DEFAULT_STEM_DICT = new CharArrayMap <>(Version.LUCENE_CURRENT, 4, false);
DEFAULT_STEM_DICT.put("fiets", "fiets"); //otherwise fiet
DEFAULT_STEM_DICT.put("bromfiets", "bromfiets"); //otherwise bromfiet
DEFAULT_STEM_DICT.put("ei", "eier");
DEFAULT_STEM_DICT.put("kind", "kinder");
}
public DutchAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable, CharArrayMap <string> stemOverrideDict)
{
this.matchVersion = matchVersion;
this.stoptable = CharArraySet.UnmodifiableSet(CharArraySet.Copy(matchVersion, stopwords));
this.excltable = CharArraySet.UnmodifiableSet(CharArraySet.Copy(matchVersion, stemExclusionTable));
#pragma warning disable 612, 618
if (stemOverrideDict.Count == 0 || !matchVersion.OnOrAfter(LuceneVersion.LUCENE_31))
#pragma warning restore 612, 618
{
this.stemdict = null;
this.origStemdict = CharArrayMap.UnmodifiableMap(CharArrayMap.Copy(matchVersion, stemOverrideDict));
}
else
{
this.origStemdict = null;
// we don't need to ignore case here since we lowercase in this analyzer anyway
StemmerOverrideFilter.Builder builder = new StemmerOverrideFilter.Builder(false);
using (CharArrayMap <string> .EntryIterator iter = (CharArrayMap <string> .EntryIterator)stemOverrideDict.EntrySet().GetEnumerator())
{
CharsRef spare = new CharsRef();
while (iter.HasNext)
{
char[] nextKey = iter.NextKey();
spare.CopyChars(nextKey, 0, nextKey.Length);
builder.Add(new string(spare.Chars), iter.CurrentValue);
}
}
try
{
this.stemdict = builder.Build();
}
catch (Exception ex) when(ex.IsIOException())
{
throw RuntimeException.Create("can not build stem dict", ex);
}
}
}
static DefaultSetHolder()
{
try
{
DEFAULT_STOP_SET = WordlistLoader.GetSnowballWordSet(
IOUtils.GetDecodingReader(typeof(SnowballFilter), DEFAULT_STOPWORD_FILE, Encoding.UTF8),
#pragma warning disable 612, 618
LuceneVersion.LUCENE_CURRENT);
#pragma warning restore 612, 618
}
catch (IOException)
{
// default set should always be present as it is part of the
// distribution (JAR)
throw new Exception("Unable to load default stopword set");
}
#pragma warning disable 612, 618
DEFAULT_STEM_DICT = new CharArrayMap <string>(LuceneVersion.LUCENE_CURRENT, 4, false);
#pragma warning restore 612, 618
DEFAULT_STEM_DICT.Put("fiets", "fiets"); //otherwise fiet
DEFAULT_STEM_DICT.Put("bromfiets", "bromfiets"); //otherwise bromfiet
DEFAULT_STEM_DICT.Put("ei", "eier");
DEFAULT_STEM_DICT.Put("kind", "kinder");
}
public virtual void testMethods()
{
CharArrayMap <int?> cm = new CharArrayMap <int?>(TEST_VERSION_CURRENT, 2, false);
Dictionary <string, int?> hm = new Dictionary <string, int?>();
hm["foo"] = 1;
hm["bar"] = 2;
cm.putAll(hm);
assertEquals(hm.Count, cm.size());
hm["baz"] = 3;
cm.putAll(hm);
assertEquals(hm.Count, cm.size());
CharArraySet cs = cm.Keys;
int n = 0;
foreach (object o in cs)
{
assertTrue(cm.containsKey(o));
char[] co = (char[])o;
assertTrue(cm.containsKey(co, 0, co.Length));
n++;
}
assertEquals(hm.Count, n);
assertEquals(hm.Count, cs.size());
assertEquals(cm.size(), cs.size());
cs.clear();
assertEquals(0, cs.size());
assertEquals(0, cm.size());
try
{
cs.add("test");
fail("keySet() allows adding new keys");
}
catch (System.NotSupportedException)
{
// pass
}
cm.putAll(hm);
assertEquals(hm.Count, cs.size());
assertEquals(cm.size(), cs.size());
IEnumerator <KeyValuePair <object, int?> > iter1 = cm.entrySet().GetEnumerator();
n = 0;
while (iter1.MoveNext())
{
KeyValuePair <object, int?> entry = iter1.Current;
object key = entry.Key;
int? val = entry.Value;
assertEquals(cm.get(key), val);
entry.Value = val * 100;
assertEquals(val * 100, (int)cm.get(key));
n++;
}
assertEquals(hm.Count, n);
cm.clear();
cm.putAll(hm);
assertEquals(cm.size(), n);
CharArrayMap <int?> .EntryIterator iter2 = cm.entrySet().GetEnumerator();
n = 0;
while (iter2.hasNext())
{
char[] keyc = iter2.nextKey();
int? val = iter2.currentValue();
assertEquals(hm[new string(keyc)], val);
iter2.Value = val * 100;
assertEquals(val * 100, (int)cm.get(keyc));
n++;
}
assertEquals(hm.Count, n);
cm.entrySet().clear();
assertEquals(0, cm.size());
assertEquals(0, cm.entrySet().size());
assertTrue(cm.Empty);
}
internal EntryIterator(CharArrayMap <V> outerInstance, bool allowModify)
{
this.outerInstance = outerInstance;
this.allowModify = allowModify;
goNext();
}
public DutchAnalyzer(Version matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable, CharArrayMap <string> stemOverrideDict)
{
this.matchVersion = matchVersion;
this.stoptable = CharArraySet.unmodifiableSet(CharArraySet.copy(matchVersion, stopwords));
this.excltable = CharArraySet.unmodifiableSet(CharArraySet.copy(matchVersion, stemExclusionTable));
if (stemOverrideDict.Empty || !matchVersion.onOrAfter(Version.LUCENE_31))
{
this.stemdict = null;
this.origStemdict = CharArrayMap.unmodifiableMap(CharArrayMap.copy(matchVersion, stemOverrideDict));
}
else
{
this.origStemdict = null;
// we don't need to ignore case here since we lowercase in this analyzer anyway
StemmerOverrideFilter.Builder builder = new StemmerOverrideFilter.Builder(false);
CharArrayMap <string> .EntryIterator iter = stemOverrideDict.entrySet().GetEnumerator();
CharsRef spare = new CharsRef();
while (iter.hasNext())
{
char[] nextKey = iter.nextKey();
spare.copyChars(nextKey, 0, nextKey.Length);
builder.add(spare, iter.currentValue());
}
try
{
this.stemdict = builder.build();
}
catch (IOException ex)
{
throw new Exception("can not build stem dict", ex);
}
}
}
public DutchAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords)
: this(matchVersion, stopwords, CharArraySet.EMPTY_SET,
matchVersion.OnOrAfter(LuceneVersion.LUCENE_36) ? DefaultSetHolder.DEFAULT_STEM_DICT : CharArrayMap <string> .EmptyMap())
{
// historically, this ctor never the stem dict!!!!!
// so we populate it only for >= 3.6
}
/// <summary>
/// Reads a stem dictionary. Each line contains:
/// <pre>word<b>\t</b>stem</pre>
/// (i.e. two tab separated words)
/// </summary>
/// <returns> stem dictionary that overrules the stemming algorithm </returns>
/// <exception cref="IOException"> If there is a low-level I/O error. </exception>
public static CharArrayMap<string> GetStemDict(TextReader reader, CharArrayMap<string> result)
{
try
{
string line;
while ((line = reader.ReadLine()) != null)
{
string[] wordstem = line.Split(new char[] { '\t' }, 2, StringSplitOptions.RemoveEmptyEntries);
result.Put(wordstem[0], wordstem[1]);
}
}
finally
{
IOUtils.Close(reader);
}
return result;
}
public DutchAnalyzer(Version matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable) : this(matchVersion, stopwords, stemExclusionTable, matchVersion.onOrAfter(Version.LUCENE_36) ? DefaultSetHolder.DEFAULT_STEM_DICT : CharArrayMap.emptyMap <string>())
{
// historically, this ctor never the stem dict!!!!!
// so we populate it only for >= 3.6
}
public DutchAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable, CharArrayMap<string> stemOverrideDict)
{
this.matchVersion = matchVersion;
this.stoptable = CharArraySet.UnmodifiableSet(CharArraySet.Copy(matchVersion, stopwords));
this.excltable = CharArraySet.UnmodifiableSet(CharArraySet.Copy(matchVersion, stemExclusionTable));
#pragma warning disable 612, 618
if (stemOverrideDict.Count == 0 || !matchVersion.OnOrAfter(LuceneVersion.LUCENE_31))
#pragma warning restore 612, 618
{
this.stemdict = null;
this.origStemdict = CharArrayMap.UnmodifiableMap(CharArrayMap.Copy(matchVersion, stemOverrideDict));
}
else
{
this.origStemdict = null;
// we don't need to ignore case here since we lowercase in this analyzer anyway
StemmerOverrideFilter.Builder builder = new StemmerOverrideFilter.Builder(false);
CharArrayMap<string>.EntryIterator iter = (CharArrayMap<string>.EntryIterator)stemOverrideDict.EntrySet().GetEnumerator();
CharsRef spare = new CharsRef();
while (iter.HasNext)
{
char[] nextKey = iter.NextKey();
spare.CopyChars(nextKey, 0, nextKey.Length);
builder.Add(new string(spare.Chars), iter.CurrentValue);
}
try
{
this.stemdict = builder.Build();
}
catch (IOException ex)
{
throw new Exception("can not build stem dict", ex);
}
}
}
public DutchAnalyzer(Version matchVersion, CharArraySet stopwords, CharArraySet stemExclusionTable, CharArrayMap<string> stemOverrideDict)
{
this.matchVersion = matchVersion;
this.stoptable = CharArraySet.unmodifiableSet(CharArraySet.copy(matchVersion, stopwords));
this.excltable = CharArraySet.unmodifiableSet(CharArraySet.copy(matchVersion, stemExclusionTable));
if (stemOverrideDict.Empty || !matchVersion.onOrAfter(Version.LUCENE_31))
{
this.stemdict = null;
this.origStemdict = CharArrayMap.unmodifiableMap(CharArrayMap.copy(matchVersion, stemOverrideDict));
}
else
{
this.origStemdict = null;
// we don't need to ignore case here since we lowercase in this analyzer anyway
StemmerOverrideFilter.Builder builder = new StemmerOverrideFilter.Builder(false);
CharArrayMap<string>.EntryIterator iter = stemOverrideDict.entrySet().GetEnumerator();
CharsRef spare = new CharsRef();
while (iter.hasNext())
{
char[] nextKey = iter.nextKey();
spare.copyChars(nextKey, 0, nextKey.Length);
builder.add(spare, iter.currentValue());
}
try
{
this.stemdict = builder.build();
}
catch (IOException ex)
{
throw new Exception("can not build stem dict", ex);
}
}
}
static DefaultSetHolder()
{
try
{
DEFAULT_STOP_SET = WordlistLoader.GetSnowballWordSet(
IOUtils.GetDecodingReader(typeof(SnowballFilter), typeof(SnowballFilter).Namespace + "." + DEFAULT_STOPWORD_FILE, Encoding.UTF8),
#pragma warning disable 612, 618
LuceneVersion.LUCENE_CURRENT);
#pragma warning restore 612, 618
}
catch (IOException)
{
// default set should always be present as it is part of the
// distribution (JAR)
throw new Exception("Unable to load default stopword set");
}
#pragma warning disable 612, 618
DEFAULT_STEM_DICT = new CharArrayMap<string>(LuceneVersion.LUCENE_CURRENT, 4, false);
#pragma warning restore 612, 618
DEFAULT_STEM_DICT.Put("fiets", "fiets"); //otherwise fiet
DEFAULT_STEM_DICT.Put("bromfiets", "bromfiets"); //otherwise bromfiet
DEFAULT_STEM_DICT.Put("ei", "eier");
DEFAULT_STEM_DICT.Put("kind", "kinder");
}
public void TestModifyOnUnmodifiable()
{
CharArrayMap<int?> map = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 2, false);
map.Put("foo", 1);
map.Put("bar", 2);
int size = map.Count;
assertEquals(2, size);
assertTrue(map.ContainsKey("foo"));
assertEquals(1, map.Get("foo"));
assertTrue(map.ContainsKey("bar"));
assertEquals(2, map.Get("bar"));
map = CharArrayMap.UnmodifiableMap(map);
assertEquals("Map size changed due to unmodifiableMap call", size, map.Count);
var NOT_IN_MAP = "SirGallahad";
assertFalse("Test String already exists in map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String already exists in map", map.Get(NOT_IN_MAP));
try
{
map.Put(NOT_IN_MAP.ToCharArray(), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
try
{
map.Put(NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
try
{
map.Put(new StringBuilder(NOT_IN_MAP), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
#region Added for better .NET support
try
{
map.Add(NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
try
{
map.Add(new KeyValuePair<string, int?>(NOT_IN_MAP, 3));
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
try
{
map[new StringBuilder(NOT_IN_MAP)] = 3;
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
try
{
#pragma warning disable 612, 618
map.Remove(new KeyValuePair<string, int?>("foo", 1));
#pragma warning restore 612, 618
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.Count);
}
#endregion
try
{
map.Clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.EntrySet().Clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.Keys.Clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.Put((object)NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.PutAll(Collections.SingletonMap<string, int?>(NOT_IN_MAP, 3));
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.ContainsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.Get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
assertTrue(map.ContainsKey("foo"));
assertEquals(1, map.Get("foo"));
assertTrue(map.ContainsKey("bar"));
assertEquals(2, map.Get("bar"));
}
public virtual void testModifyOnUnmodifiable()
{
CharArrayMap<int?> map = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 2, false);
map.put("foo",1);
map.put("bar",2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int size = map.size();
int size = map.size();
assertEquals(2, size);
assertTrue(map.containsKey("foo"));
assertEquals(1, map.get("foo").intValue());
assertTrue(map.containsKey("bar"));
assertEquals(2, map.get("bar").intValue());
map = CharArrayMap.unmodifiableMap(map);
assertEquals("Map size changed due to unmodifiableMap call", size, map.size());
string NOT_IN_MAP = "SirGallahad";
assertFalse("Test String already exists in map", map.containsKey(NOT_IN_MAP));
assertNull("Test String already exists in map", map.get(NOT_IN_MAP));
try
{
map.put(NOT_IN_MAP.ToCharArray(), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put(NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put(new StringBuilder(NOT_IN_MAP), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.entrySet().clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.Keys.Clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put((object) NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.putAll(Collections.singletonMap(NOT_IN_MAP, 3));
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
assertTrue(map.containsKey("foo"));
assertEquals(1, map.get("foo").intValue());
assertTrue(map.containsKey("bar"));
assertEquals(2, map.get("bar").intValue());
}
public virtual void TestMethods()
{
CharArrayMap<int?> cm = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 2, false);
Dictionary<string, int?> hm = new Dictionary<string, int?>();
hm["foo"] = 1;
hm["bar"] = 2;
cm.PutAll(hm);
assertEquals(hm.Count, cm.Count);
hm["baz"] = 3;
cm.PutAll(hm);
assertEquals(hm.Count, cm.Count);
// LUCENENET: Need to cast here - no implicit conversion.
CharArraySet cs = cm.Keys as CharArraySet;
int n = 0;
foreach (string o in cs)
{
assertTrue(cm.ContainsKey(o));
char[] co = o.ToCharArray();
assertTrue(cm.ContainsKey(co, 0, co.Length));
n++;
}
assertEquals(hm.Count, n);
assertEquals(hm.Count, cs.Count);
assertEquals(cm.Count, cs.Count);
cs.Clear();
assertEquals(0, cs.Count);
assertEquals(0, cm.Count);
try
{
cs.Add("test");
fail("keySet() allows adding new keys");
}
catch (System.NotSupportedException)
{
// pass
}
cm.PutAll(hm);
assertEquals(hm.Count, cs.Count);
assertEquals(cm.Count, cs.Count);
// LUCENENET: Need to cast here - no implicit conversion
IEnumerator<KeyValuePair<string, int?>> iter1 = (IEnumerator<KeyValuePair<string, int?>>)cm.EntrySet().GetEnumerator();
n = 0;
while (iter1.MoveNext())
{
KeyValuePair<string, int?> entry = iter1.Current;
object key = entry.Key;
int? val = entry.Value;
assertEquals(cm.Get(key), val);
// LUCENENET: Need a cast to get to this method because it is not part of the IEnumerator<T> interface
((CharArrayMap<int?>.EntryIterator)iter1).SetValue(val * 100);
assertEquals(val * 100, (int)cm.Get(key));
n++;
}
assertEquals(hm.Count, n);
cm.Clear();
cm.PutAll(hm);
assertEquals(cm.size(), n);
CharArrayMap<int?>.EntryIterator iter2 = cm.EntrySet().GetEnumerator() as CharArrayMap<int?>.EntryIterator;
n = 0;
while (iter2.MoveNext())
{
var keyc = iter2.Current.Key;
int? val = iter2.Current.Value;
assertEquals(hm[keyc], val);
iter2.SetValue(val * 100);
assertEquals(val * 100, (int)cm.Get(keyc));
n++;
}
assertEquals(hm.Count, n);
cm.EntrySet().Clear();
assertEquals(0, cm.size());
assertEquals(0, cm.EntrySet().size());
assertTrue(cm.Count == 0);
}
static DefaultSetHolder()
{
try
{
DEFAULT_STOP_SET = WordlistLoader.getSnowballWordSet(IOUtils.getDecodingReader(typeof(SnowballFilter), DEFAULT_STOPWORD_FILE, StandardCharsets.UTF_8), Version.LUCENE_CURRENT);
}
catch (IOException)
{
// default set should always be present as it is part of the
// distribution (JAR)
throw new Exception("Unable to load default stopword set");
}
DEFAULT_STEM_DICT = new CharArrayMap<>(Version.LUCENE_CURRENT, 4, false);
DEFAULT_STEM_DICT.put("fiets", "fiets"); //otherwise fiet
DEFAULT_STEM_DICT.put("bromfiets", "bromfiets"); //otherwise bromfiet
DEFAULT_STEM_DICT.put("ei", "eier");
DEFAULT_STEM_DICT.put("kind", "kinder");
}
internal EntrySet(CharArrayMap <V> outerInstance, bool allowModify)
{
this.outerInstance = outerInstance;
this.allowModify = allowModify;
}
/// <summary>
/// Reads a stem dictionary. Each line contains:
/// <pre>word<b>\t</b>stem</pre>
/// (i.e. two tab separated words)
/// </summary>
/// <returns> stem dictionary that overrules the stemming algorithm </returns>
/// <exception cref="IOException"> If there is a low-level I/O error. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static CharArrayMap<String> getStemDict(java.io.Reader reader, CharArrayMap<String> result) throws java.io.IOException
public static CharArrayMap<string> getStemDict(Reader reader, CharArrayMap<string> result)
{
BufferedReader br = null;
try
{
br = getBufferedReader(reader);
string line;
while ((line = br.readLine()) != null)
{
string[] wordstem = line.Split("\t", 2);
result.put(wordstem[0], wordstem[1]);
}
}
finally
{
IOUtils.close(br);
}
return result;
}
public CharArraySetAnonymousInnerClassHelper(CharArrayMap <V> outerInstance, CharArrayMap (CharArrayMap) this) : base((CharArrayMap)this)
public virtual void testModifyOnUnmodifiable()
{
CharArrayMap <int?> map = new CharArrayMap <int?>(TEST_VERSION_CURRENT, 2, false);
map.put("foo", 1);
map.put("bar", 2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int size = map.size();
int size = map.size();
assertEquals(2, size);
assertTrue(map.containsKey("foo"));
assertEquals(1, map.get("foo").intValue());
assertTrue(map.containsKey("bar"));
assertEquals(2, map.get("bar").intValue());
map = CharArrayMap.unmodifiableMap(map);
assertEquals("Map size changed due to unmodifiableMap call", size, map.size());
string NOT_IN_MAP = "SirGallahad";
assertFalse("Test String already exists in map", map.containsKey(NOT_IN_MAP));
assertNull("Test String already exists in map", map.get(NOT_IN_MAP));
try
{
map.put(NOT_IN_MAP.ToCharArray(), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put(NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put(new StringBuilder(NOT_IN_MAP), 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.entrySet().clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.Keys.Clear();
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.put((object)NOT_IN_MAP, 3);
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
try
{
map.putAll(Collections.singletonMap(NOT_IN_MAP, 3));
fail("Modified unmodifiable map");
}
catch (System.NotSupportedException)
{
// expected
assertFalse("Test String has been added to unmodifiable map", map.containsKey(NOT_IN_MAP));
assertNull("Test String has been added to unmodifiable map", map.get(NOT_IN_MAP));
assertEquals("Size of unmodifiable map has changed", size, map.size());
}
assertTrue(map.containsKey("foo"));
assertEquals(1, map.get("foo").intValue());
assertTrue(map.containsKey("bar"));
assertEquals(2, map.get("bar").intValue());
}
internal MapEntry(CharArrayMap <V> outerInstance, int pos, bool allowModify)
{
this.outerInstance = outerInstance;
this.pos = pos;
this.allowModify = allowModify;
}
public virtual void testToString()
{
CharArrayMap<int?> cm = new CharArrayMap<int?>(TEST_VERSION_CURRENT, Collections.singletonMap("test",1), false);
assertEquals("[test]",cm.Keys.ToString());
assertEquals("[1]",cm.values().ToString());
assertEquals("[test=1]",cm.entrySet().ToString());
assertEquals("{test=1}",cm.ToString());
cm.put("test2", 2);
assertTrue(cm.Keys.ToString().Contains(", "));
assertTrue(cm.values().ToString().Contains(", "));
assertTrue(cm.entrySet().ToString().Contains(", "));
assertTrue(cm.ToString().Contains(", "));
}
UnmodifiableCharArrayMap(CharArrayMap <V> map)
{
base(map);
}
public virtual void testMethods()
{
CharArrayMap<int?> cm = new CharArrayMap<int?>(TEST_VERSION_CURRENT, 2, false);
Dictionary<string, int?> hm = new Dictionary<string, int?>();
hm["foo"] = 1;
hm["bar"] = 2;
cm.putAll(hm);
assertEquals(hm.Count, cm.size());
hm["baz"] = 3;
cm.putAll(hm);
assertEquals(hm.Count, cm.size());
CharArraySet cs = cm.Keys;
int n = 0;
foreach (object o in cs)
{
assertTrue(cm.containsKey(o));
char[] co = (char[]) o;
assertTrue(cm.containsKey(co, 0, co.Length));
n++;
}
assertEquals(hm.Count, n);
assertEquals(hm.Count, cs.size());
assertEquals(cm.size(), cs.size());
cs.clear();
assertEquals(0, cs.size());
assertEquals(0, cm.size());
try
{
cs.add("test");
fail("keySet() allows adding new keys");
}
catch (System.NotSupportedException)
{
// pass
}
cm.putAll(hm);
assertEquals(hm.Count, cs.size());
assertEquals(cm.size(), cs.size());
IEnumerator<KeyValuePair<object, int?>> iter1 = cm.entrySet().GetEnumerator();
n = 0;
while (iter1.MoveNext())
{
KeyValuePair<object, int?> entry = iter1.Current;
object key = entry.Key;
int? val = entry.Value;
assertEquals(cm.get(key), val);
entry.Value = val * 100;
assertEquals(val * 100, (int)cm.get(key));
n++;
}
assertEquals(hm.Count, n);
cm.clear();
cm.putAll(hm);
assertEquals(cm.size(), n);
CharArrayMap<int?>.EntryIterator iter2 = cm.entrySet().GetEnumerator();
n = 0;
while (iter2.hasNext())
{
char[] keyc = iter2.nextKey();
int? val = iter2.currentValue();
assertEquals(hm[new string(keyc)], val);
iter2.Value = val * 100;
assertEquals(val * 100, (int)cm.get(keyc));
n++;
}
assertEquals(hm.Count, n);
cm.entrySet().clear();
assertEquals(0, cm.size());
assertEquals(0, cm.entrySet().size());
assertTrue(cm.Empty);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void testEmptyStemDictionary() throws java.io.IOException
public virtual void testEmptyStemDictionary()
{
DutchAnalyzer a = new DutchAnalyzer(TEST_VERSION_CURRENT, CharArraySet.EMPTY_SET, CharArraySet.EMPTY_SET, CharArrayMap.emptyMap <string>());
checkOneTerm(a, "fiets", "fiet");
}
private static CharArrayMap<DictEntry> initializeDictHash()
{
DictEntry defaultEntry;
DictEntry entry;
CharArrayMap<DictEntry> d = new CharArrayMap<DictEntry>(Version.LUCENE_CURRENT, 1000, false);
for (int i = 0; i < exceptionWords.Length; i++)
{
if (!d.containsKey(exceptionWords[i]))
{
entry = new DictEntry(exceptionWords[i], true);
d.put(exceptionWords[i], entry);
}
else
{
throw new Exception("Warning: Entry [" + exceptionWords[i] + "] already in dictionary 1");
}
}
for (int i = 0; i < directConflations.Length; i++)
{
if (!d.containsKey(directConflations[i][0]))
{
entry = new DictEntry(directConflations[i][1], false);
d.put(directConflations[i][0], entry);
}
else
{
throw new Exception("Warning: Entry [" + directConflations[i][0] + "] already in dictionary 2");
}
}
for (int i = 0; i < countryNationality.Length; i++)
{
if (!d.containsKey(countryNationality[i][0]))
{
entry = new DictEntry(countryNationality[i][1], false);
d.put(countryNationality[i][0], entry);
}
else
{
throw new Exception("Warning: Entry [" + countryNationality[i][0] + "] already in dictionary 3");
}
}
defaultEntry = new DictEntry(null, false);
string[] array;
array = KStemData1.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData2.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData3.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData4.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData5.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData6.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
array = KStemData7.data;
for (int i = 0; i < array.Length; i++)
{
if (!d.containsKey(array[i]))
{
d.put(array[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + array[i] + "] already in dictionary 4");
}
}
for (int i = 0; i < KStemData8.data.Length; i++)
{
if (!d.containsKey(KStemData8.data[i]))
{
d.put(KStemData8.data[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + KStemData8.data[i] + "] already in dictionary 4");
}
}
for (int i = 0; i < supplementDict.Length; i++)
{
if (!d.containsKey(supplementDict[i]))
{
d.put(supplementDict[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + supplementDict[i] + "] already in dictionary 5");
}
}
for (int i = 0; i < properNouns.Length; i++)
{
if (!d.containsKey(properNouns[i]))
{
d.put(properNouns[i], defaultEntry);
}
else
{
throw new Exception("Warning: Entry [" + properNouns[i] + "] already in dictionary 6");
}
}
return d;
}
