public void Test01() { IntlStrings intl; HybridDictionary hd; const int BIG_LENGTH = 100; // simple string values string[] valuesShort = { "", " ", "$%^#", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // keys for simple string values string[] keysShort = { Int32.MaxValue.ToString(), " ", System.DateTime.Today.ToString(), "", "$%^#" }; string[] valuesLong = new string[BIG_LENGTH]; string[] keysLong = new string[BIG_LENGTH]; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); for (int i = 0; i < BIG_LENGTH; i++) { valuesLong[i] = "Item" + i; keysLong[i] = "keY" + i; } // [] HybridDictionary is constructed as expected //----------------------------------------------------------------- hd = new HybridDictionary(); // [] Contains on empty dictionary Assert.Throws<ArgumentNullException>(() => { hd.Contains(null); }); if (hd.Contains("some_string")) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } // [] simple strings and Contains() // cnt = hd.Count; int len = valuesShort.Length; for (int i = 0; i < len; i++) { hd.Add(keysShort[i], valuesShort[i]); } if (hd.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, valuesShort.Length)); } // for (int i = 0; i < len; i++) { if (!hd.Contains(keysShort[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysShort[i])); } } cnt = hd.Count; len = valuesLong.Length; for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); } if (hd.Count != len + cnt) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len + cnt)); } // verify new keys for (int i = 0; i < len; i++) { if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysLong[i])); } } // verify old keys for (int i = 0; i < valuesShort.Length; i++) { if (!hd.Contains(keysShort[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysShort[i])); } } // // [] Intl strings and Contains() // string[] intlValues = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } hd.Clear(); for (int i = 0; i < len; i++) { hd.Add(intlValues[i + len], intlValues[i]); } if (hd.Count != (len)) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len)); } for (int i = 0; i < len; i++) { // if (!hd.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, intlValues[i + len])); } } // // [] Case sensitivity // by default HybridDictionary is case-sensitive // hd.Clear(); len = valuesLong.Length; // // will use first half of array as valuesShort and second half as keysShort // for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); // adding uppercase strings } // for (int i = 0; i < len; i++) { // uppercase key if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain added uppercase \"{1}\"", i, keysLong[i])); } // lowercase key if (hd.Contains(keysLong[i].ToUpper())) { Assert.False(true, string.Format("Error, contains uppercase \"{1}\" - should not", i, keysLong[i].ToUpper())); } } // [] different_in_casing_only keys and Contains() // hd.Clear(); string[] ks = { "Key", "kEy", "keY" }; len = ks.Length; for (int i = 0; i < len; i++) { hd.Add(ks[i], "Value" + i); } if (hd.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len)); } if (hd.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } cnt = hd.Count; len = valuesLong.Length; for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); } if (hd.Count != len + cnt) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len + cnt)); } // verify new keys for (int i = 0; i < len; i++) { if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysLong[i])); } } // verify old keys for (int i = 0; i < ks.Length; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, ks[i])); } } // // [] Contains(null) - for filled dictionary // len = valuesShort.Length; hd.Clear(); for (int i = 0; i < len; i++) { hd.Add(keysShort[i], valuesShort[i]); } Assert.Throws<ArgumentNullException>(() => { hd.Contains(null); }); // [] Contains() for case-insensitive comparer dictionary // hd = new HybridDictionary(true); hd.Clear(); len = ks.Length; hd.Add(ks[0], "Value0"); for (int i = 1; i < len; i++) { Assert.Throws<ArgumentException>(() => { hd.Add(ks[i], "Value" + i); }); } if (hd.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 1)); } if (hd.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (!hd.Contains("KEY")) { Assert.False(true, string.Format("Error, returned false non-existing-cased key")); } // [] few not_overriding_Equals objects and Contains() // hd = new HybridDictionary(); hd.Clear(); Hashtable[] lbl = new Hashtable[2]; lbl[0] = new Hashtable(); lbl[1] = new Hashtable(); ArrayList[] b = new ArrayList[2]; b[0] = new ArrayList(); b[1] = new ArrayList(); hd.Add(lbl[0], b[0]); hd.Add(lbl[1], b[1]); Assert.Throws<ArgumentException>(() => { hd.Add(lbl[0], "Hello"); }); if (hd.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 2)); } if (!hd.Contains(lbl[0])) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!hd.Contains(lbl[1])) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] many not_overriding_Equals objects and Contains() // hd = new HybridDictionary(); hd.Clear(); int num = 40; lbl = new Hashtable[num]; b = new ArrayList[num]; for (int i = 0; i < num; i++) { lbl[i] = new Hashtable(); b[i] = new ArrayList(); hd.Add(lbl[i], b[i]); } Assert.Throws<ArgumentException>(() => { hd.Add(lbl[0], "Hello"); }); if (hd.Count != num) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, num)); } for (int i = 0; i < num; i++) { if (!hd.Contains(lbl[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] few not_overriding_Equals structs and Contains() hd = new HybridDictionary(); SpecialStruct s = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; SpecialStruct s1 = new SpecialStruct(); s1.Num = 1; s1.Wrd = "one"; hd.Add(s, "first"); hd.Add(s1, "second"); if (hd.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 2)); } if (!hd.Contains(s)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!hd.Contains(s1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } // [] many not_overriding_Equals structs and Contains() hd = new HybridDictionary(); SpecialStruct[] ss = new SpecialStruct[num]; for (int i = 0; i < num; i++) { ss[i] = new SpecialStruct(); ss[i].Num = i; ss[i].Wrd = "value" + i; hd.Add(ss[i], "item" + i); } if (hd.Count != num) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, num)); } for (int i = 0; i < num; i++) { if (!hd.Contains(ss[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } s = new SpecialStruct(); s.Num = 1; s.Wrd = "value1"; if (hd.Contains(s)) { Assert.False(true, string.Format("Error, returned true when false expected")); } }
public void Test01() { IntlStrings intl; ListDictionary ld; // simple string values string[] values = { "", " ", "a", "aA", "text", " SPaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // keys for simple string values string[] keys = { "zero", "oNe", " ", "", "aa", "1", System.DateTime.Today.ToString(), "$%^#", Int32.MaxValue.ToString(), " spaces", "2222222222222222222222222" }; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); // [] ListDictionary is constructed as expected //----------------------------------------------------------------- ld = new ListDictionary(); // [] Contains() on empty dictionary // Assert.Throws<ArgumentNullException>(() => { ld.Contains(null); }); if (ld.Contains("some_string")) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } if (ld.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } // [] simple strings and Contains() // cnt = ld.Count; int len = values.Length; for (int i = 0; i < len; i++) { ld.Add(keys[i], values[i]); } if (ld.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, values.Length)); } // for (int i = 0; i < len; i++) { if (!ld.Contains(keys[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keys[i])); } } // // Intl strings // [] Intl strings and Contains() // string[] intlValues = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) val = intl.GetRandomString(MAX_LEN); intlValues[i] = val; } Boolean caseInsensitive = false; for (int i = 0; i < len * 2; i++) { if (intlValues[i].Length != 0 && intlValues[i].ToLower() == intlValues[i].ToUpper()) caseInsensitive = true; } ld.Clear(); for (int i = 0; i < len; i++) { ld.Add(intlValues[i + len], intlValues[i]); } if (ld.Count != (len)) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, len)); } for (int i = 0; i < len; i++) { // if (!ld.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, intlValues[i + len])); } } // // [] Case sensitivity // by default ListDictionary is case-sensitive // string[] intlValuesLower = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { intlValues[i] = intlValues[i].ToUpper(); } for (int i = 0; i < len * 2; i++) { intlValuesLower[i] = intlValues[i].ToLower(); } ld.Clear(); // // will use first half of array as values and second half as keys // for (int i = 0; i < len; i++) { ld.Add(intlValues[i + len], intlValues[i]); // adding uppercase strings } // for (int i = 0; i < len; i++) { // uppercase key if (!ld.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain added uppercase \"{1}\"", i, intlValues[i + len])); } // lowercase key if (!caseInsensitive && ld.Contains(intlValuesLower[i + len])) { Assert.False(true, string.Format("Error, contains lowercase \"{1}\" - should not", i, intlValuesLower[i + len])); } } // [] different_in_casing_only keys and Contains() // ld.Clear(); string[] ks = { "Key", "kEy", "keY" }; len = ks.Length; for (int i = 0; i < len; i++) { ld.Add(ks[i], "Value" + i); } if (ld.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, len)); } if (ld.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!ld.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } // // [] Contains(null) - for filled dictionary // ld.Clear(); for (int i = 0; i < len; i++) { ld.Add(keys[i], values[i]); } Assert.Throws<ArgumentNullException>(() => { ld.Contains(null); }); // [] Contains() for case-insensitive comparer // ld = new ListDictionary(new InsensitiveComparer()); ld.Clear(); len = ks.Length; ld.Add(ks[0], "Value0"); for (int i = 1; i < len; i++) { Assert.Throws<ArgumentException>(() => { ld.Add(ks[i], "Value" + i); }); } if (ld.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 1)); } if (ld.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!ld.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (!ld.Contains("KEY")) { Assert.False(true, string.Format("Error, returned false non-existing-cased key")); } // [] Contains() and objects_not_overriding_Equals // ld = new ListDictionary(); ld.Clear(); Hashtable lbl = new Hashtable(); Hashtable lbl1 = new Hashtable(); ArrayList b = new ArrayList(); ArrayList b1 = new ArrayList(); ld.Add(lbl, b); ld.Add(lbl1, b1); Assert.Throws<ArgumentException>(() => { ld.Add(lbl, "Hello"); }); if (ld.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 2)); } if (!ld.Contains(lbl)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (ld.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] Contains and Special_Comparer for objects // ld = new ListDictionary(new SpecialComparer()); lbl["foo"] = "Hello"; lbl1["foo"] = "Hello"; ld.Add(lbl, b); Assert.Throws<ArgumentException>(() => { ld.Add(lbl1, b1); }); if (ld.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 1)); } if (!ld.Contains(lbl)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } lbl1["foo"] = "HELLO"; if (ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] Contains() and special_structs_not_overriding_Equals ld = new ListDictionary(); SpecialStruct s = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; SpecialStruct s1 = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; ld.Add(s, "first"); ld.Add(s1, "second"); if (ld.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 2)); } if (!ld.Contains(s)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(s1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } }
public void Test01() { IntlStrings intl; HybridDictionary hd; const int BIG_LENGTH = 100; // simple string values string[] valuesShort = { "", " ", "$%^#", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // keys for simple string values string[] keysShort = { Int32.MaxValue.ToString(), " ", System.DateTime.Today.ToString(), "", "$%^#" }; string[] valuesLong = new string[BIG_LENGTH]; string[] keysLong = new string[BIG_LENGTH]; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); for (int i = 0; i < BIG_LENGTH; i++) { valuesLong[i] = "Item" + i; keysLong[i] = "keY" + i; } // [] HybridDictionary is constructed as expected //----------------------------------------------------------------- hd = new HybridDictionary(); // [] Contains on empty dictionary Assert.Throws <ArgumentNullException>(() => { hd.Contains(null); }); if (hd.Contains("some_string")) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } // [] simple strings and Contains() // cnt = hd.Count; int len = valuesShort.Length; for (int i = 0; i < len; i++) { hd.Add(keysShort[i], valuesShort[i]); } if (hd.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, valuesShort.Length)); } // for (int i = 0; i < len; i++) { if (!hd.Contains(keysShort[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysShort[i])); } } cnt = hd.Count; len = valuesLong.Length; for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); } if (hd.Count != len + cnt) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len + cnt)); } // verify new keys for (int i = 0; i < len; i++) { if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysLong[i])); } } // verify old keys for (int i = 0; i < valuesShort.Length; i++) { if (!hd.Contains(keysShort[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysShort[i])); } } // // [] Intl strings and Contains() // string[] intlValues = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) { val = intl.GetRandomString(MAX_LEN); } intlValues[i] = val; } hd.Clear(); for (int i = 0; i < len; i++) { hd.Add(intlValues[i + len], intlValues[i]); } if (hd.Count != (len)) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len)); } for (int i = 0; i < len; i++) { // if (!hd.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, intlValues[i + len])); } } // // [] Case sensitivity // by default HybridDictionary is case-sensitive // hd.Clear(); len = valuesLong.Length; // // will use first half of array as valuesShort and second half as keysShort // for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); // adding uppercase strings } // for (int i = 0; i < len; i++) { // uppercase key if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain added uppercase \"{1}\"", i, keysLong[i])); } // lowercase key if (hd.Contains(keysLong[i].ToUpper())) { Assert.False(true, string.Format("Error, contains uppercase \"{1}\" - should not", i, keysLong[i].ToUpper())); } } // [] different_in_casing_only keys and Contains() // hd.Clear(); string[] ks = { "Key", "kEy", "keY" }; len = ks.Length; for (int i = 0; i < len; i++) { hd.Add(ks[i], "Value" + i); } if (hd.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len)); } if (hd.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } cnt = hd.Count; len = valuesLong.Length; for (int i = 0; i < len; i++) { hd.Add(keysLong[i], valuesLong[i]); } if (hd.Count != len + cnt) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, len + cnt)); } // verify new keys for (int i = 0; i < len; i++) { if (!hd.Contains(keysLong[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keysLong[i])); } } // verify old keys for (int i = 0; i < ks.Length; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, ks[i])); } } // // [] Contains(null) - for filled dictionary // len = valuesShort.Length; hd.Clear(); for (int i = 0; i < len; i++) { hd.Add(keysShort[i], valuesShort[i]); } Assert.Throws <ArgumentNullException>(() => { hd.Contains(null); }); // [] Contains() for case-insensitive comparer dictionary // hd = new HybridDictionary(true); hd.Clear(); len = ks.Length; hd.Add(ks[0], "Value0"); for (int i = 1; i < len; i++) { Assert.Throws <ArgumentException>(() => { hd.Add(ks[i], "Value" + i); }); } if (hd.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 1)); } if (hd.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!hd.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (!hd.Contains("KEY")) { Assert.False(true, string.Format("Error, returned false non-existing-cased key")); } // [] few not_overriding_Equals objects and Contains() // hd = new HybridDictionary(); hd.Clear(); Hashtable[] lbl = new Hashtable[2]; lbl[0] = new Hashtable(); lbl[1] = new Hashtable(); ArrayList[] b = new ArrayList[2]; b[0] = new ArrayList(); b[1] = new ArrayList(); hd.Add(lbl[0], b[0]); hd.Add(lbl[1], b[1]); Assert.Throws <ArgumentException>(() => { hd.Add(lbl[0], "Hello"); }); if (hd.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 2)); } if (!hd.Contains(lbl[0])) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!hd.Contains(lbl[1])) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] many not_overriding_Equals objects and Contains() // hd = new HybridDictionary(); hd.Clear(); int num = 40; lbl = new Hashtable[num]; b = new ArrayList[num]; for (int i = 0; i < num; i++) { lbl[i] = new Hashtable(); b[i] = new ArrayList(); hd.Add(lbl[i], b[i]); } Assert.Throws <ArgumentException>(() => { hd.Add(lbl[0], "Hello"); }); if (hd.Count != num) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, num)); } for (int i = 0; i < num; i++) { if (!hd.Contains(lbl[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (hd.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] few not_overriding_Equals structs and Contains() hd = new HybridDictionary(); SpecialStruct s = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; SpecialStruct s1 = new SpecialStruct(); s1.Num = 1; s1.Wrd = "one"; hd.Add(s, "first"); hd.Add(s1, "second"); if (hd.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, 2)); } if (!hd.Contains(s)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!hd.Contains(s1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } // [] many not_overriding_Equals structs and Contains() hd = new HybridDictionary(); SpecialStruct[] ss = new SpecialStruct[num]; for (int i = 0; i < num; i++) { ss[i] = new SpecialStruct(); ss[i].Num = i; ss[i].Wrd = "value" + i; hd.Add(ss[i], "item" + i); } if (hd.Count != num) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", hd.Count, num)); } for (int i = 0; i < num; i++) { if (!hd.Contains(ss[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } s = new SpecialStruct(); s.Num = 1; s.Wrd = "value1"; if (hd.Contains(s)) { Assert.False(true, string.Format("Error, returned true when false expected")); } }
public void Test01() { IntlStrings intl; ListDictionary ld; // simple string values string[] values = { "", " ", "a", "aA", "text", " SPaces", "1", "$%^#", "2222222222222222222222222", System.DateTime.Today.ToString(), Int32.MaxValue.ToString() }; // keys for simple string values string[] keys = { "zero", "oNe", " ", "", "aa", "1", System.DateTime.Today.ToString(), "$%^#", Int32.MaxValue.ToString(), " spaces", "2222222222222222222222222" }; int cnt = 0; // Count // initialize IntStrings intl = new IntlStrings(); // [] ListDictionary is constructed as expected //----------------------------------------------------------------- ld = new ListDictionary(); // [] Contains() on empty dictionary // Assert.Throws <ArgumentNullException>(() => { ld.Contains(null); }); if (ld.Contains("some_string")) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } if (ld.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, empty dictionary contains some_object")); } // [] simple strings and Contains() // cnt = ld.Count; int len = values.Length; for (int i = 0; i < len; i++) { ld.Add(keys[i], values[i]); } if (ld.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, values.Length)); } // for (int i = 0; i < len; i++) { if (!ld.Contains(keys[i])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, keys[i])); } } // // Intl strings // [] Intl strings and Contains() // string[] intlValues = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { string val = intl.GetRandomString(MAX_LEN); while (Array.IndexOf(intlValues, val) != -1) { val = intl.GetRandomString(MAX_LEN); } intlValues[i] = val; } Boolean caseInsensitive = false; for (int i = 0; i < len * 2; i++) { if (intlValues[i].Length != 0 && intlValues[i].ToLower() == intlValues[i].ToUpper()) { caseInsensitive = true; } } ld.Clear(); for (int i = 0; i < len; i++) { ld.Add(intlValues[i + len], intlValues[i]); } if (ld.Count != (len)) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, len)); } for (int i = 0; i < len; i++) { // if (!ld.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain \"{1}\"", i, intlValues[i + len])); } } // // [] Case sensitivity // by default ListDictionary is case-sensitive // string[] intlValuesLower = new string[len * 2]; // fill array with unique strings // for (int i = 0; i < len * 2; i++) { intlValues[i] = intlValues[i].ToUpper(); } for (int i = 0; i < len * 2; i++) { intlValuesLower[i] = intlValues[i].ToLower(); } ld.Clear(); // // will use first half of array as values and second half as keys // for (int i = 0; i < len; i++) { ld.Add(intlValues[i + len], intlValues[i]); // adding uppercase strings } // for (int i = 0; i < len; i++) { // uppercase key if (!ld.Contains(intlValues[i + len])) { Assert.False(true, string.Format("Error, doesn't contain added uppercase \"{1}\"", i, intlValues[i + len])); } // lowercase key if (!caseInsensitive && ld.Contains(intlValuesLower[i + len])) { Assert.False(true, string.Format("Error, contains lowercase \"{1}\" - should not", i, intlValuesLower[i + len])); } } // [] different_in_casing_only keys and Contains() // ld.Clear(); string[] ks = { "Key", "kEy", "keY" }; len = ks.Length; for (int i = 0; i < len; i++) { ld.Add(ks[i], "Value" + i); } if (ld.Count != len) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, len)); } if (ld.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!ld.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } // // [] Contains(null) - for filled dictionary // ld.Clear(); for (int i = 0; i < len; i++) { ld.Add(keys[i], values[i]); } Assert.Throws <ArgumentNullException>(() => { ld.Contains(null); }); // [] Contains() for case-insensitive comparer // ld = new ListDictionary(new InsensitiveComparer()); ld.Clear(); len = ks.Length; ld.Add(ks[0], "Value0"); for (int i = 1; i < len; i++) { Assert.Throws <ArgumentException>(() => { ld.Add(ks[i], "Value" + i); }); } if (ld.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 1)); } if (ld.Contains("Value0")) { Assert.False(true, string.Format("Error, returned true when should not")); } for (int i = 0; i < len; i++) { if (!ld.Contains(ks[i])) { Assert.False(true, string.Format("Error, returned false when true expected", i)); } } if (!ld.Contains("KEY")) { Assert.False(true, string.Format("Error, returned false non-existing-cased key")); } // [] Contains() and objects_not_overriding_Equals // ld = new ListDictionary(); ld.Clear(); Hashtable lbl = new Hashtable(); Hashtable lbl1 = new Hashtable(); ArrayList b = new ArrayList(); ArrayList b1 = new ArrayList(); ld.Add(lbl, b); ld.Add(lbl1, b1); Assert.Throws <ArgumentException>(() => { ld.Add(lbl, "Hello"); }); if (ld.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 2)); } if (!ld.Contains(lbl)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (ld.Contains(new Hashtable())) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] Contains and Special_Comparer for objects // ld = new ListDictionary(new SpecialComparer()); lbl["foo"] = "Hello"; lbl1["foo"] = "Hello"; ld.Add(lbl, b); Assert.Throws <ArgumentException>(() => { ld.Add(lbl1, b1); }); if (ld.Count != 1) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 1)); } if (!ld.Contains(lbl)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } lbl1["foo"] = "HELLO"; if (ld.Contains(lbl1)) { Assert.False(true, string.Format("Error, returned true when false expected")); } // [] Contains() and special_structs_not_overriding_Equals ld = new ListDictionary(); SpecialStruct s = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; SpecialStruct s1 = new SpecialStruct(); s.Num = 1; s.Wrd = "one"; ld.Add(s, "first"); ld.Add(s1, "second"); if (ld.Count != 2) { Assert.False(true, string.Format("Error, count is {0} instead of {1}", ld.Count, 2)); } if (!ld.Contains(s)) { Assert.False(true, string.Format("Error, returned false when true expected")); } if (!ld.Contains(s1)) { Assert.False(true, string.Format("Error, returned false when true expected")); } }