public void CanGetDictionaryKeysAndValues() { int[] keys = new int[] { 1, 2, 3 }; string[] vals = new string[] { "alpha", "beta", "gamma" }; PairDictionary <int, string> test = new PairDictionary <int, string>(); for (int i = 0; i < keys.Length; i++) { test.Add(keys[i], vals[i]); } Assert.AreEqual(keys.Length, test.Count); IList <int> testKeys = test.Keys; IList <string> testVals = test.Values; Assert.AreEqual(test.Count, testKeys.Count); Assert.AreEqual(test.Count, testVals.Count); // Make sure that the contained keys / values are correct. for (int i = 0; i < keys.Length; i++) { Assert.AreEqual(keys[i], testKeys[i]); Assert.AreEqual(vals[i], testVals[i]); } }
public void CanUseSameKeyAndValueTypes() { const string DOG = "Dog"; const string HORSE = "Horse"; const string PET = "Pet"; const string FOOD = "Food"; PairDictionary <string, string> test = new PairDictionary <string, string>() { { DOG, PET }, { HORSE, FOOD } }; // NOTE: This syntax won't work because of ambiguity. // Uncomment it and try it out. // string val = test[DOG]; // Make sure that the value associations will work. Assert.AreEqual(PET, test.Value(DOG)); Assert.AreEqual(FOOD, test.Value(HORSE)); // Make sure the key associations works. Assert.AreEqual(DOG, test.Key(PET)); Assert.AreEqual(HORSE, test.Key(FOOD)); }
public void CantAddDuplicateValues() { PairDictionary <int, string> test = new PairDictionary <int, string>(); const string DUPE = "ABC"; test.Add(1, DUPE); // KABOOM! test.Add(2, DUPE); }
public void CantAddDuplicateKeys() { PairDictionary <string, int> test = new PairDictionary <string, int>(); const string DUPE = "ABC"; test.Add(DUPE, 1); // KABOOM! test.Add(DUPE, 2); }
// -------------------------------------------------------------------------------------------------------------------------- public InspectionReport CompareObjects(Type type, object source, object comp, bool throwOnFail = false) { CachedReports = new MultiDictionary <object, object, InspectionReport>(); SrcRefCache = new PairDictionary <object, int>(); CompRefCache = new PairDictionary <object, int>(); InspectionReport res = InternalCompare(type, source, comp, null, throwOnFail); // Cleanup and return... CachedReports.Clear(); CachedReports = null; return(res); }
public void CanSetValuesViaKeys() { const string KEY = "x"; const int VAL_1 = 100; const int VAL_2 = 1000; PairDictionary <string, int> test = new PairDictionary <string, int>(); test.Add(KEY, VAL_1); // Set the value, and make sure that it took! test[KEY] = VAL_2; Assert.AreEqual(VAL_2, test[KEY]); }
public void CanUseKeyComparer() { PairDictionary <string, int> test = new PairDictionary <string, int>(StringComparer.OrdinalIgnoreCase); test.Add(ONE, 1); test.Add(TWO, 2); test.Add(THREE, 3); // See, the formatting no longer matters. Assert.AreEqual(1, test[ONE.ToLower()]); Assert.AreEqual(2, test[TWO.ToUpper()]); Assert.AreEqual(3, test["tHreE"]); // TODO: Include a check to show that we will get an exception if we use odd formatting as well. // 'DrewCo.UnitTesting' ?? }
// -------------------------------------------------------------------------------------------------------------------------- public ObjectInspector() { CachedReports = new MultiDictionary <object, object, InspectionReport>(); SrcRefCache = new PairDictionary <object, int>(); CompRefCache = new PairDictionary <object, int>(); }