public void Copy6() { var d1 = new DependencyGraph(); d1.AddDependency("b", "a"); d1.AddDependency("e", "d"); var d2 = new DependencyGraph(d1); d1.AddDependency("c", "a"); d2.AddDependency("f", "d"); Assert.AreEqual(2, new List <string>(d1.GetDependees("a")).Count); Assert.AreEqual(1, new List <string>(d1.GetDependees("d")).Count); Assert.AreEqual(2, new List <string>(d2.GetDependees("d")).Count); Assert.AreEqual(1, new List <string>(d2.GetDependees("a")).Count); }
public void GetDependees1() { DependencyGraph dg = new DependencyGraph(); IEnumerator <string> empty = dg.GetDependees("a").GetEnumerator(); Assert.IsFalse(empty.MoveNext()); }
public void EmptyTest3() { DependencyGraph t = new DependencyGraph(); Assert.IsFalse(t.GetDependees("x").GetEnumerator().MoveNext()); Assert.IsFalse(t.GetDependents("x").GetEnumerator().MoveNext()); }
public void NonEmptyTest19() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "b"); t.AddDependency("a", "z"); t.ReplaceDependents("b", new HashSet <string>()); t.AddDependency("y", "b"); t.ReplaceDependents("a", new HashSet <string>() { "c" }); t.AddDependency("w", "d"); t.ReplaceDependees("b", new HashSet <string>() { "a", "c" }); t.ReplaceDependees("d", new HashSet <string>() { "b" }); IEnumerator <string> e = t.GetDependees("a").GetEnumerator(); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("b").GetEnumerator(); Assert.IsTrue(e.MoveNext()); String s1 = e.Current; Assert.IsTrue(e.MoveNext()); String s2 = e.Current; Assert.IsFalse(e.MoveNext()); Assert.IsTrue(((s1 == "a") && (s2 == "c")) || ((s1 == "c") && (s2 == "a"))); e = t.GetDependees("c").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("a", e.Current); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("d").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("b", e.Current); Assert.IsFalse(e.MoveNext()); }
public void EmptyTest9() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "y"); IEnumerator <string> e1 = t.GetDependees("y").GetEnumerator(); Assert.IsTrue(e1.MoveNext()); Assert.AreEqual("x", e1.Current); IEnumerator <string> e2 = t.GetDependents("x").GetEnumerator(); Assert.IsTrue(e2.MoveNext()); Assert.AreEqual("y", e2.Current); t.RemoveDependency("x", "y"); Assert.IsFalse(t.GetDependees("y").GetEnumerator().MoveNext()); Assert.IsFalse(t.GetDependents("x").GetEnumerator().MoveNext()); }
public void MethodsOnHugeGraph() { // Checks HasDependents and HasDependees Methods Assert.IsTrue(hugeGraph.HasDependents("0a")); Assert.IsTrue(hugeGraph.HasDependees("0b")); // Creates list for ReplaceDependents and ReplaceDependees Methods List <string> stringList = new List <string>(); for (int i = 0; i < 10; i++) { stringList.Add("new " + i); } // Checks ReplaceDependents and ReplaceDependees Methods hugeGraph.ReplaceDependents("0a", stringList); Assert.IsTrue(hugeGraph.HasDependents("0a")); hugeGraph.ReplaceDependees("0b", stringList); Assert.IsTrue(hugeGraph.HasDependees("0b")); // Checks HasDependents and HasDependees Methods to make sure the new dependencies have been added properly Assert.IsTrue(hugeGraph.HasDependents("new 0")); Assert.IsTrue(hugeGraph.HasDependees("new 0")); // Checks RemoveDependency Method hugeGraph.RemoveDependency("0a", "0b"); hugeGraph.RemoveDependency("0a", "new 0"); Assert.IsFalse(hugeGraph.HasDependees("new 0")); Assert.IsTrue(hugeGraph.HasDependents("0a")); // Checks GetDependents and GetDependees Methods foreach (string s in hugeGraph.GetDependees("0a")) { if (s.Equals("new 1")) { break; } else { Assert.Fail(); } } foreach (string s in hugeGraph.GetDependents("new 0")) { if (s.Equals("0b")) { break; } else { Assert.Fail(); } } }
public void NonEmptyTest14() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "y"); t.AddDependency("a", "b"); t.AddDependency("a", "c"); t.AddDependency("a", "d"); t.AddDependency("c", "b"); t.RemoveDependency("a", "d"); t.AddDependency("e", "b"); t.AddDependency("b", "d"); t.RemoveDependency("e", "b"); t.RemoveDependency("x", "y"); IEnumerator <string> e = t.GetDependees("a").GetEnumerator(); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("b").GetEnumerator(); Assert.IsTrue(e.MoveNext()); String s1 = e.Current; Assert.IsTrue(e.MoveNext()); String s2 = e.Current; Assert.IsFalse(e.MoveNext()); Assert.IsTrue(((s1 == "a") && (s2 == "c")) || ((s1 == "c") && (s2 == "a"))); e = t.GetDependees("c").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("a", e.Current); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("d").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("b", e.Current); Assert.IsFalse(e.MoveNext()); }
public void GetDependeesEmptyTest() { DependencyGraph g = new DependencyGraph(); g.AddDependency("A", "B"); g.AddDependency("A", "C"); string result = ""; foreach (string s in g.GetDependees("A")) { result += s + " "; } Assert.AreEqual("", result); }
public void Copy7() { var d1 = new DependencyGraph(); for (int i = 0; i < 100; i++) { for (int j = 0; j <= i; j++) { d1.AddDependency(i.ToString(), j.ToString()); } } var d2 = new DependencyGraph(d1); for (int i = 0; i < 100; i++) { d1.RemoveDependency(i.ToString(), i.ToString()); d2.AddDependency(i.ToString(), "x"); } for (int i = 0; i < 100; i++) { Assert.AreEqual(i, new List <string>(d1.GetDependents(i.ToString())).Count); Assert.AreEqual(i + 2, new List <string>(d2.GetDependents(i.ToString())).Count); } for (int j = 0; j <= 50; j++) { Assert.AreEqual(99 - j, new List <string>(d1.GetDependees(j.ToString())).Count); Assert.AreEqual(100 - j, new List <string>(d2.GetDependees(j.ToString())).Count); } Assert.AreEqual(100, new List <string>(d2.GetDependees("x")).Count); Assert.AreEqual(5050 - 100, d1.Size); Assert.AreEqual(5050 + 100, d2.Size); }
public void GetDependees2() { DependencyGraph dg = new DependencyGraph(); for (int i = 0; i < 10; i++) { dg.AddDependency(i.ToString(), "a"); } IEnumerator <string> list = dg.GetDependees("a").GetEnumerator(); int j = 0; while (list.MoveNext()) { Assert.IsTrue(list.Current == j.ToString()); j++; } }
public void NullGet() { DependencyGraph g = new DependencyGraph(); g.AddDependency("A", "B"); // Get Dependees / Dependents try { g.AddDependency("A1", "B1"); g.GetDependees(null); Assert.Fail(); } catch (ArgumentNullException) { } try { g.AddDependency("A1", "B1"); g.GetDependents(null); Assert.Fail(); } catch (ArgumentNullException) { } }
public void AddTest6() { DependencyGraph dg = new DependencyGraph(); dg.AddDependency("a2", "a1"); dg.AddDependency("a3", "a1"); dg.AddDependency("a4", "a1"); dg.AddDependency("a5", "a1"); dg.AddDependency("a6", "a1"); HashSet <String> dependees = new HashSet <string>(dg.GetDependees("a1")); Assert.IsTrue(dependees.Count == 5); Assert.IsTrue(dependees.Contains("a2")); Assert.IsTrue(dependees.Contains("a3")); Assert.IsTrue(dependees.Contains("a4")); Assert.IsTrue(dependees.Contains("a5")); Assert.IsTrue(dependees.Contains("a6")); }
public void GetDependees3() { DependencyGraph dg = new DependencyGraph(); for (int i = 0; i < 100; i++) { dg.AddDependency(i.ToString(), "a"); } for (int i = 50; i < 100; i++) { dg.RemoveDependency(i.ToString(), "a"); } IEnumerator <string> list = dg.GetDependees("a").GetEnumerator(); for (int j = 0; j < 50; j++) { list.MoveNext(); Assert.IsTrue(list.Current == j.ToString()); } }
public void replaceDependees() { DependencyGraph dg = new DependencyGraph(); dg.AddDependency("a2", "a1"); dg.AddDependency("a3", "a1"); dg.AddDependency("a4", "a1"); dg.AddDependency("a5", "a1"); dg.AddDependency("a6", "a1"); dg.ReplaceDependees("a1", new HashSet <string>() { "a7", "a8", "a9", "a10", "a11", "a12" }); HashSet <String> testDependentsHashTable = new HashSet <string>(dg.GetDependees("a1")); Assert.IsTrue(testDependentsHashTable.Contains("a8")); Assert.IsTrue(testDependentsHashTable.Contains("a9")); Assert.IsTrue(testDependentsHashTable.Contains("a10")); Assert.IsTrue(testDependentsHashTable.Contains("a11")); Assert.IsTrue(testDependentsHashTable.Contains("a12")); Assert.IsTrue(testDependentsHashTable.Contains("a7")); }
public void NonEmptyTest19() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "b"); t.AddDependency("a", "z"); t.ReplaceDependents("b", new HashSet<string>()); t.AddDependency("y", "b"); t.ReplaceDependents("a", new HashSet<string>() { "c" }); t.AddDependency("w", "d"); t.ReplaceDependees("b", new HashSet<string>() { "a", "c" }); t.ReplaceDependees("d", new HashSet<string>() { "b" }); IEnumerator<string> e = t.GetDependees("a").GetEnumerator(); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("b").GetEnumerator(); Assert.IsTrue(e.MoveNext()); String s1 = e.Current; Assert.IsTrue(e.MoveNext()); String s2 = e.Current; Assert.IsFalse(e.MoveNext()); Assert.IsTrue(((s1 == "a") && (s2 == "c")) || ((s1 == "c") && (s2 == "a"))); e = t.GetDependees("c").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("a", e.Current); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("d").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("b", e.Current); Assert.IsFalse(e.MoveNext()); }
public void StressTest1() { // Dependency graph DependencyGraph t = new DependencyGraph(); // A bunch of strings to use const int SIZE = 200; string[] letters = new string[SIZE]; for (int i = 0; i < SIZE; i++) { letters[i] = ("" + (char)('a' + i)); } // The correct answers HashSet<string>[] dents = new HashSet<string>[SIZE]; HashSet<string>[] dees = new HashSet<string>[SIZE]; for (int i = 0; i < SIZE; i++) { dents[i] = new HashSet<string>(); dees[i] = new HashSet<string>(); } // Add a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j++) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 4; j < SIZE; j += 4) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Add some back for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j += 2) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove some more for (int i = 0; i < SIZE; i += 2) { for (int j = i + 3; j < SIZE; j += 3) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Make sure everything is right for (int i = 0; i < SIZE; i++) { Assert.IsTrue(dents[i].SetEquals(new HashSet<string>(t.GetDependents(letters[i])))); Assert.IsTrue(dees[i].SetEquals(new HashSet<string>(t.GetDependees(letters[i])))); } }
public void Copy7() { var d1 = new DependencyGraph(); for (int i = 0; i < 100; i++) { for (int j = 0; j <= i; j++) { d1.AddDependency(i.ToString(), j.ToString()); } } var d2 = new DependencyGraph(d1); for (int i = 0; i < 100; i++) { d1.RemoveDependency(i.ToString(), i.ToString()); d2.AddDependency(i.ToString(), "x"); } for (int i = 0; i < 100; i++) { Assert.AreEqual(i, new List<string>(d1.GetDependents(i.ToString())).Count); Assert.AreEqual(i + 2, new List<string>(d2.GetDependents(i.ToString())).Count); } for (int j = 0; j <= 50; j++) { Assert.AreEqual(99 - j, new List<string>(d1.GetDependees(j.ToString())).Count); Assert.AreEqual(100 - j, new List<string>(d2.GetDependees(j.ToString())).Count); } Assert.AreEqual(100, new List<string>(d2.GetDependees("x")).Count); Assert.AreEqual(5050 - 100, d1.Size); Assert.AreEqual(5050 + 100, d2.Size); }
public void StressTest15() { // Dependency graph DependencyGraph t = new DependencyGraph(); // A bunch of strings to use const int SIZE = 800; string[] letters = new string[SIZE]; for (int i = 0; i < SIZE; i++) { letters[i] = ("" + (char)('a' + i)); } // The correct answers HashSet<string>[] dents = new HashSet<string>[SIZE]; HashSet<string>[] dees = new HashSet<string>[SIZE]; for (int i = 0; i < SIZE; i++) { dents[i] = new HashSet<string>(); dees[i] = new HashSet<string>(); } // Add a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j++) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 2; j < SIZE; j += 3) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Replace a bunch of dependees for (int i = 0; i < SIZE; i += 2) { HashSet<string> newDees = new HashSet<String>(); for (int j = 0; j < SIZE; j += 9) { newDees.Add(letters[j]); } t.ReplaceDependees(letters[i], newDees); foreach (string s in dees[i]) { dents[s[0] - 'a'].Remove(letters[i]); } foreach (string s in newDees) { dents[s[0] - 'a'].Add(letters[i]); } dees[i] = newDees; } // Make sure everything is right for (int i = 0; i < SIZE; i++) { Assert.IsTrue(dents[i].SetEquals(new HashSet<string>(t.GetDependents(letters[i])))); Assert.IsTrue(dees[i].SetEquals(new HashSet<string>(t.GetDependees(letters[i])))); } }
public void TestGetDependeesNull() { DependencyGraph dg = new DependencyGraph(); dg.GetDependees(null); }
public void NonEmptyTest14() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "y"); t.AddDependency("a", "b"); t.AddDependency("a", "c"); t.AddDependency("a", "d"); t.AddDependency("c", "b"); t.RemoveDependency("a", "d"); t.AddDependency("e", "b"); t.AddDependency("b", "d"); t.RemoveDependency("e", "b"); t.RemoveDependency("x", "y"); IEnumerator<string> e = t.GetDependees("a").GetEnumerator(); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("b").GetEnumerator(); Assert.IsTrue(e.MoveNext()); String s1 = e.Current; Assert.IsTrue(e.MoveNext()); String s2 = e.Current; Assert.IsFalse(e.MoveNext()); Assert.IsTrue(((s1 == "a") && (s2 == "c")) || ((s1 == "c") && (s2 == "a"))); e = t.GetDependees("c").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("a", e.Current); Assert.IsFalse(e.MoveNext()); e = t.GetDependees("d").GetEnumerator(); Assert.IsTrue(e.MoveNext()); Assert.AreEqual("b", e.Current); Assert.IsFalse(e.MoveNext()); }
public void PassingNullTests() { DependencyGraph g = new DependencyGraph(); g.AddDependency("A", "B"); List <string> stringList = new List <string>(); stringList.Add("1a"); stringList.Add(null); try { g.AddDependency("A", null); Assert.Fail(); } catch (Exception) { } try { g.AddDependency(null, "B"); Assert.Fail(); } catch (Exception) { } try { g.AddDependency(null, null); Assert.Fail(); } catch (Exception) { } try { g.GetDependees(null); Assert.Fail(); } catch (Exception) { } try { g.GetDependents(null); Assert.Fail(); } catch (Exception) { } try { g.HasDependees(null); Assert.Fail(); } catch (Exception) { } try { g.HasDependents(null); Assert.Fail(); } catch (Exception) { } try { g.RemoveDependency("A", null); Assert.Fail(); } catch (Exception) { } try { g.RemoveDependency(null, "B"); Assert.Fail(); } catch (Exception) { } try { g.ReplaceDependees(null, stringList); Assert.Fail(); } catch (Exception) { } try { stringList = null; g.ReplaceDependees("A", stringList); Assert.Fail(); } catch (Exception) { } try { g.ReplaceDependents(null, stringList); Assert.Fail(); } catch (Exception) { } try { stringList = null; g.ReplaceDependents("A", stringList); Assert.Fail(); } catch (Exception) { } }
public void StressTest1() { // Dependency graph DependencyGraph t = new DependencyGraph(); // A bunch of strings to use const int SIZE = 200; string[] letters = new string[SIZE]; for (int i = 0; i < SIZE; i++) { letters[i] = ("" + (char)('a' + i)); } // The correct answers HashSet <string>[] dents = new HashSet <string> [SIZE]; HashSet <string>[] dees = new HashSet <string> [SIZE]; for (int i = 0; i < SIZE; i++) { dents[i] = new HashSet <string>(); dees[i] = new HashSet <string>(); } // Add a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j++) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 4; j < SIZE; j += 4) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Add some back for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j += 2) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove some more for (int i = 0; i < SIZE; i += 2) { for (int j = i + 3; j < SIZE; j += 3) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Make sure everything is right for (int i = 0; i < SIZE; i++) { Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(t.GetDependents(letters[i])))); Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(t.GetDependees(letters[i])))); } }
public void EmptyTest3() { DependencyGraph t = new DependencyGraph(); Assert.IsFalse(t.GetDependees("x").GetEnumerator().MoveNext()); Assert.IsFalse(t.GetDependents("x").GetEnumerator().MoveNext()); }
public void Copy6() { var d1 = new DependencyGraph(); d1.AddDependency("b", "a"); d1.AddDependency("e", "d"); var d2 = new DependencyGraph(d1); d1.AddDependency("c", "a"); d2.AddDependency("f", "d"); Assert.AreEqual(2, new List<string>(d1.GetDependees("a")).Count); Assert.AreEqual(1, new List<string>(d1.GetDependees("d")).Count); Assert.AreEqual(2, new List<string>(d2.GetDependees("d")).Count); Assert.AreEqual(1, new List<string>(d2.GetDependees("a")).Count); }
public void StressTest15() { // Dependency graph DependencyGraph t = new DependencyGraph(); // A bunch of strings to use const int SIZE = 800; string[] letters = new string[SIZE]; for (int i = 0; i < SIZE; i++) { letters[i] = ("" + (char)('a' + i)); } // The correct answers HashSet <string>[] dents = new HashSet <string> [SIZE]; HashSet <string>[] dees = new HashSet <string> [SIZE]; for (int i = 0; i < SIZE; i++) { dents[i] = new HashSet <string>(); dees[i] = new HashSet <string>(); } // Add a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 1; j < SIZE; j++) { t.AddDependency(letters[i], letters[j]); dents[i].Add(letters[j]); dees[j].Add(letters[i]); } } // Remove a bunch of dependencies for (int i = 0; i < SIZE; i++) { for (int j = i + 2; j < SIZE; j += 3) { t.RemoveDependency(letters[i], letters[j]); dents[i].Remove(letters[j]); dees[j].Remove(letters[i]); } } // Replace a bunch of dependees for (int i = 0; i < SIZE; i += 2) { HashSet <string> newDees = new HashSet <String>(); for (int j = 0; j < SIZE; j += 9) { newDees.Add(letters[j]); } t.ReplaceDependees(letters[i], newDees); foreach (string s in dees[i]) { dents[s[0] - 'a'].Remove(letters[i]); } foreach (string s in newDees) { dents[s[0] - 'a'].Add(letters[i]); } dees[i] = newDees; } // Make sure everything is right for (int i = 0; i < SIZE; i++) { Assert.IsTrue(dents[i].SetEquals(new HashSet <string>(t.GetDependents(letters[i])))); Assert.IsTrue(dees[i].SetEquals(new HashSet <string>(t.GetDependees(letters[i])))); } }
public void SimpleTest4() { DependencyGraph dg = new DependencyGraph(); Assert.IsFalse(dg.GetDependees("a").GetEnumerator().MoveNext()); }
public void EmptyTest9() { DependencyGraph t = new DependencyGraph(); t.AddDependency("x", "y"); IEnumerator<string> e1 = t.GetDependees("y").GetEnumerator(); Assert.IsTrue(e1.MoveNext()); Assert.AreEqual("x", e1.Current); IEnumerator<string> e2 = t.GetDependents("x").GetEnumerator(); Assert.IsTrue(e2.MoveNext()); Assert.AreEqual("y", e2.Current); t.RemoveDependency("x", "y"); Assert.IsFalse(t.GetDependees("y").GetEnumerator().MoveNext()); Assert.IsFalse(t.GetDependents("x").GetEnumerator().MoveNext()); }