public void NonEmptyTest18()
{
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"
});
Assert.IsTrue(t.HasDependents("a"));
Assert.IsFalse(t.HasDependees("a"));
Assert.IsTrue(t.HasDependents("b"));
Assert.IsTrue(t.HasDependees("b"));
}
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 HasDependees3()
{
DependencyGraph dg = new DependencyGraph();
dg.AddDependency("a", "c");
dg.AddDependency("b", "c");
dg.RemoveDependency("a", "c");
Assert.IsTrue(dg.HasDependees("c"));
dg.RemoveDependency("b", "c");
Assert.IsFalse(dg.HasDependees("c"));
}
public void EmptyTest8()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("x", "y");
Assert.IsTrue(t.HasDependees("y"));
Assert.IsTrue(t.HasDependents("x"));
t.RemoveDependency("x", "y");
Assert.IsFalse(t.HasDependees("y"));
Assert.IsFalse(t.HasDependents("x"));
}
public void HasDependentAndDependee()
{
DependencyGraph g = new DependencyGraph();
g.AddDependency("a", "b");
g.AddDependency("a", "b");
Assert.AreEqual(1, g.Size);
Assert.IsTrue(g.HasDependents("a"));
Assert.IsTrue(g.HasDependees("b"));
Assert.IsFalse(g.HasDependees("a"));
Assert.IsFalse(g.HasDependents("b"));
}
public void NonEmptyTest3()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("a", "b");
t.AddDependency("a", "c");
t.AddDependency("c", "b");
t.AddDependency("b", "d");
Assert.IsTrue(t.HasDependents("a"));
Assert.IsFalse(t.HasDependees("a"));
Assert.IsTrue(t.HasDependents("b"));
Assert.IsTrue(t.HasDependees("b"));
}
public void EmptyTest2()
{
DependencyGraph t = new DependencyGraph();
Assert.IsFalse(t.HasDependees("x"));
Assert.IsFalse(t.HasDependents("x"));
}
public void HasDependees0()
{
DependencyGraph dg = new DependencyGraph();
string a = null;
Assert.IsFalse(dg.HasDependees(a));
}
public void EmptyGraphTests()
{
DependencyGraph g = new DependencyGraph();
Assert.AreEqual(g.Size, 0);
Assert.IsFalse(g.HasDependents("a"));
Assert.IsFalse(g.HasDependees("b"));
}
public void SimpleTest8()
{
DependencyGraph dg = new DependencyGraph();
dg.AddDependency("m", "b");
dg.AddDependency("m", "c");
Assert.IsFalse(dg.HasDependees("m"));
}
public void HasDependees2()
{
DependencyGraph dg = new DependencyGraph();
dg.AddDependency("a", "b");
dg.AddDependency("c", "b");
Assert.IsTrue(dg.HasDependees("b"));
}
public void AddTest3()
{
DependencyGraph dg = new DependencyGraph();
dg.AddDependency("a", "b");
dg.AddDependency("a", "c");
dg.AddDependency("a", "c");
dg.AddDependency("d", "c");
dg.AddDependency("g", "c");
Assert.AreEqual(true, dg.HasDependents("a"));
Assert.AreEqual(true, dg.HasDependees("b"));
Assert.AreEqual(false, dg.HasDependents("b"));
Assert.AreEqual(true, dg.HasDependees("c"));
Assert.AreEqual(true, dg.HasDependents("d"));
Assert.AreEqual(false, dg.HasDependents("c"));
Assert.AreEqual(4, dg.Size);
}
public void Copy4()
{
var d1 = new DependencyGraph();
d1.AddDependency("a", "b");
var d2 = new DependencyGraph(d1);
Assert.IsTrue(d1.HasDependees("b"));
Assert.IsTrue(d2.HasDependees("b"));
}
public void RemoveDependency()
{
DependencyGraph g = new DependencyGraph();
g.AddDependency("Dependent", "Dependee");
g.RemoveDependency("Dependent", "Dependee");
Assert.IsFalse(g.HasDependents("Dependent"));
Assert.IsFalse(g.HasDependees("Dependee"));
Assert.AreEqual(0, g.Size);
}
public void RemoveDependencyOnEmpty()
{
DependencyGraph g = new DependencyGraph();
g.RemoveDependency("Dependee", "Dependent");
Assert.IsFalse(g.HasDependees("Dependee"));
Assert.IsFalse(g.HasDependents("Dependent"));
Assert.AreEqual(0, g.Size);
Console.WriteLine(g.ToString());
}
public void ReplaceMethodsOnEmpty()
{
DependencyGraph g = new DependencyGraph();
g.AddDependency("Dependee", "Dependent");
List <string> stringList = new List <string>();
for (int i = 1; i < 11; i++)
{
stringList.Add(i + "");
}
Assert.IsFalse(g.HasDependees("Dependee"));
g.ReplaceDependees("Dependee", stringList);
Assert.IsTrue(g.HasDependees("Dependee"));
Assert.IsFalse(g.HasDependents("Dependent"));
g.ReplaceDependents("Dependent", stringList);
Assert.IsTrue(g.HasDependents("Dependent"));
Console.WriteLine(g.ToString());
}
public void ReplaceDependentsOnEmpty()
{
List <string> stringList = new List <string>();
for (int i = 0; i < 10; i++)
{
stringList.Add(i + "a");
}
DependencyGraph g = new DependencyGraph();
g.ReplaceDependents("Dependee", stringList);
Assert.IsFalse(g.HasDependees("0a"));
Assert.AreEqual(0, g.Size);
}
public void ReplaceDependees()
{
List <string> stringList = new List <string>();
for (int i = 0; i < 10; i++)
{
stringList.Add(i + "a");
}
DependencyGraph g = new DependencyGraph();
g.AddDependency("Dependee", "Dependent");
g.AddDependency("A", "B");
stringList.Add("B");
g.ReplaceDependees("Dependent", stringList);
Assert.IsTrue(g.HasDependees("Dependent"));
Assert.IsFalse(g.HasDependents("Dependee"));
Assert.AreEqual(12, g.Size);
}
public void NullHas()
{
DependencyGraph g = new DependencyGraph();
g.AddDependency("A", "B");
// Has Dependees / Dependents
try {
g.AddDependency("A1", "B1");
g.HasDependees(null);
Assert.Fail();
} catch (ArgumentNullException) {
}
try {
g.AddDependency("A1", "B1");
g.HasDependents(null);
Assert.Fail();
} catch (ArgumentNullException) {
}
}
public void EmptyTest2()
{
DependencyGraph t = new DependencyGraph();
Assert.IsFalse(t.HasDependees("x"));
Assert.IsFalse(t.HasDependents("x"));
}
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 NonEmptyTest18()
{
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" });
Assert.IsTrue(t.HasDependents("a"));
Assert.IsFalse(t.HasDependees("a"));
Assert.IsTrue(t.HasDependents("b"));
Assert.IsTrue(t.HasDependees("b"));
}
public void SimpleTest2()
{
DependencyGraph dg = new DependencyGraph();
Assert.AreEqual(false, dg.HasDependees("c"));
}
public void EmptyTest8()
{
DependencyGraph t = new DependencyGraph();
t.AddDependency("x", "y");
Assert.IsTrue(t.HasDependees("y"));
Assert.IsTrue(t.HasDependents("x"));
t.RemoveDependency("x", "y");
Assert.IsFalse(t.HasDependees("y"));
Assert.IsFalse(t.HasDependents("x"));
}
public void Null2()
{
DependencyGraph d = new DependencyGraph();
d.HasDependees(null);
}
public void Copy4()
{
var d1 = new DependencyGraph();
d1.AddDependency("a", "b");
var d2 = new DependencyGraph(d1);
Assert.IsTrue(d1.HasDependees("b"));
Assert.IsTrue(d2.HasDependees("b"));
}
public void Null2()
{
DependencyGraph d = new DependencyGraph();
d.HasDependees(null);
}
public void NonEmptyTest13()
{
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");
Assert.IsTrue(t.HasDependents("a"));
Assert.IsFalse(t.HasDependees("a"));
Assert.IsTrue(t.HasDependents("b"));
Assert.IsTrue(t.HasDependees("b"));
}
public void HasDependees1()
{
DependencyGraph dg = new DependencyGraph();
Assert.IsFalse(dg.HasDependees("a"));
}
