public void Iterator()
{
var d1 = new[] { "Foo", "Bar", "Baz" };
var d2 = new[] { "One", "Two", "Three", "Four", "Five" };
var d3 = new[] { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturnday", "Sunday" };
var d = new HyperDictionary <string, int>(3);
var v = 1;
foreach (var k1 in d1)
{
foreach (var k2 in d2)
{
foreach (var k3 in d3)
{
d[k1, k2, k3] = v++;
}
}
}
var l = d1.Length * d2.Length * d3.Length;
Assert.AreEqual(l, d.Count);
var c = 0;
foreach (var kvp in d)
{
Assert.AreEqual(c++ + 1, kvp.Value);
}
Assert.AreEqual(l, c);
Assert.AreEqual(l, d[d1.Reverse().First(), d2.Reverse().First(), d3.Reverse().First()]);
}
public void ICollectionCopyToThrowsArgumentIndexExceptionWithArrayIndexPastEnd()
{
var d = new HyperDictionary();
d.Add("foo", "bar");
d.Add("baz", "boo");
d.CopyTo(new KeyValuePair<string, object>[2], 1);
}
public void ExtendedPropertiesWork()
{
var baz = new string[] { "hello", "there" };
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChild(two);
two.ExtendProperty("baz", new object[] { 2, 3, 4 }); //NOTE: Integers, not strings!
//Other verification (sanity)
Assert.AreEqual("foo value", two["foo"]);
Assert.AreEqual("bar value", two["bar"]);
Assert.IsFalse(two.HasOwnProperty("foo"));
Assert.IsFalse(two.HasOwnProperty("bar"));
//Interesting assertions for this test
Assert.IsTrue(two.HasOwnProperty("baz"));
Assert.AreEqual("hello there 2 3 4", String.Join(" ", two["baz"] as IEnumerable<object>));
Assert.AreEqual("hello there", String.Join(" ", one["baz"] as IEnumerable<object>));
}
public void AddChildAddsItemToChildrenOfParent()
{
var one = new HyperDictionary();
var two = new HyperDictionary();
one.AddChild(two);
var oneChildrenInfo = one.GetType().GetField("children", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var oneChildren = oneChildrenInfo.GetValue(one) as IEnumerable<HyperDictionary>;
Assert.IsTrue(oneChildren.Contains(two));
}
void Init(HyperDictionary <TKey, TValue> data)
{
GrandTotal = aggregatorFactories.Select(f => f.Create()).ToArray();
foreach (var kvp in data)
{
foreach (var a in GrandTotal)
{
a.Add(kvp.Value);
}
}
}
public void Basics()
{
var d = new HyperDictionary <string, int>(3)
{
{ 1, "Foo", "Blah", "Blubb" },
{ 2, "Bar", "Blah", "Blubb" },
{ 3, "Baz", "Blah", "Blubb" }
};
Assert.AreEqual(1, d["Foo", "Blah", "Blubb"]);
Assert.AreEqual(2, d["Bar", "Blah", "Blubb"]);
Assert.AreEqual(3, d["Baz", "Blah", "Blubb"]);
Assert.ThrowsException <ArgumentException>(() => d.Add(3, "Baz", "Blah", "Blubb"));
d["Baz", "Blah", "Blubb"] = 4;
Assert.AreEqual(4, d["Baz", "Blah", "Blubb"]);
Assert.ThrowsException <KeyNotFoundException>(() => d["a", "b", "c"]);
Assert.AreEqual(3, d.Count);
d.Clear();
Assert.AreEqual(0, d.Count);
}
public Pivot(HyperDictionary <TKey, TValue> data, IEnumerable <IAggregatorFactory> factories)
{
aggregatorFactories = factories.ToArray();
Init(data);
}
public PivotTest()
{
_data = new HyperDictionary <string, int>(2)
{
private static dynamic InhertiableHyperDictionary()
{
Console.WriteLine("Using HyperDictionary to show dictionary inheritance\n==================================================");
var top = new HyperDictionary("top");
top["eyes"] = "brown";
top["hair"] = "pointy";
var second = new HyperDictionary("second");
second.InheritsFrom(top);
second["hair"] = "straight";
Console.WriteLine("top[\"eyes\"]:\t{0}", top["eyes"]);
Console.WriteLine("top[\"hair\"]:\t{0}", top["hair"]);
Console.WriteLine("second[\"eyes\"]:\t{0}", second["eyes"]);
Console.WriteLine("second[\"hair\"]:\t{0}", second["hair"]);
//Extends and removes using an IEnumerable<object> value
top["things"] = new string[] { "first thing", "second thing" };
var third = new HyperDictionary("third");
third.InheritsFrom(second);
third.RemoveProperty("hair");
third.ExtendProperty("things", new object[] { 3, 4, 5 });
//Output members of third - note the absence of "hair" member
Console.Write("third members:\n");
foreach (object o in third)
{
Console.WriteLine(o);
}
Console.WriteLine();
// Output the extended list of items in "things",
// some from top and some from third.
// And notice: DIFFERENT DATA TYPES!
Console.Write("third things:\t");
var things = third["things"] as IEnumerable<object>;
foreach (object thing in things)
{
Console.Write(" | " + thing.ToString());
}
Console.Write(" | ");
Console.WriteLine();
Console.WriteLine("Making sure TryGetProperty works...should have 'not set' as the next value...");
object stomach;
if (third.TryGetProperty("stomach", out stomach)) Console.WriteLine("third\tstomach:\t{0}", stomach);
else Console.WriteLine("not set - third.stomach");
Console.WriteLine();
Pause();
return third;
}
public void ICollectionCopyToThrowsArgumentIndexExceptionWithTooSmallDestinationArray()
{
var d = new HyperDictionary();
d.Add("foo", "bar");
d.Add("baz", "boo");
d.CopyTo(new KeyValuePair<string, object>[1], 0);
}
public void ICollectionCopyToWithZeroArrayIndexWorks()
{
var a = new KeyValuePair<string, object>[3];
a[0] = new KeyValuePair<string, object>("first", null);
a[1] = new KeyValuePair<string, object>("second", "i'm second");
a[2] = new KeyValuePair<string, object>("third", "i'm third");
var d = new HyperDictionary();
d.Add("1st", "HyperDictionary first");
d.Add("2nd", "HyperDictionary second");
d.CopyTo(a, 0);
Assert.AreEqual("1st", a[0].Key);
Assert.AreEqual("HyperDictionary first", a[0].Value);
Assert.AreEqual("2nd", a[1].Key);
Assert.AreEqual("HyperDictionary second", a[1].Value);
Assert.AreEqual("third", a[2].Key);
Assert.AreEqual("i'm third", a[2].Value);
}
public void ThreeLevelPropertiesWork()
{
var baz = new string[] { "hello", "there" };
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
var twoPrime = new HyperDictionary("two'");
var three = new HyperDictionary("three");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChildren(new HyperDictionary[] { two, twoPrime });
two.ExtendProperty("baz", new object[] { 2, 3, 4 }); //NOTE: Integers, not strings!
three.InheritsFrom(two);
three["bar"] = "three bar value";
three.ExtendProperty("baz", new object[] { "three-baz" });
//Other verification (sanity)
Assert.AreEqual("foo value", two["foo"]);
Assert.AreEqual("bar value", two["bar"]);
Assert.IsFalse(two.HasOwnProperty("foo"));
Assert.IsFalse(two.HasOwnProperty("bar"));
//Interesting assertions for this test
Assert.AreSame(one["foo"], twoPrime["foo"]);
Assert.AreSame(one["bar"], twoPrime["bar"]);
Assert.AreSame(one["baz"], twoPrime["baz"]);
Assert.IsTrue(two.HasOwnProperty("baz"));
Assert.IsTrue(three.HasOwnProperty("baz"));
Assert.IsTrue(three.HasOwnProperty("bar"));
Assert.IsFalse(three.HasOwnProperty("foo"));
Assert.AreEqual("foo value", three["foo"]);
Assert.AreEqual("three bar value", three["bar"]);
Assert.AreEqual("hello there 2 3 4", String.Join(" ", two["baz"] as IEnumerable<object>));
Assert.AreEqual("hello there", String.Join(" ", one["baz"] as IEnumerable<object>));
Assert.AreEqual("hello there 2 3 4 three-baz", String.Join(" ", three["baz"] as IEnumerable<object>));
}
public void ICollectionValuesOwnedPropertiesWork()
{
var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary();
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
var values = one.Values;
Assert.IsTrue(values.Contains("foo value"));
Assert.IsTrue(values.Contains("bar value"));
Assert.IsTrue(values.Contains(baz));
}
public void OwnedPropertiesWork()
{
var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary();
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
Assert.AreEqual("foo value", one["foo"]);
Assert.AreEqual("bar value", one["bar"]);
Assert.AreSame(baz, one["baz"]);
Assert.IsTrue(one.HasOwnProperty("foo"));
Assert.IsTrue(one.HasOwnProperty("bar"));
Assert.IsTrue(one.HasOwnProperty("baz"));
}
public void OverriddenPropertiesWork()
{
var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChild(two);
two["bar"] = "two's bar value";
//Other verification (sanity)
Assert.AreEqual("foo value", two["foo"]);
Assert.AreSame(baz, two["baz"]);
Assert.IsFalse(two.HasOwnProperty("foo"));
Assert.IsFalse(two.HasOwnProperty("baz"));
//Interesting assertions for this test
Assert.AreEqual("two's bar value", two["bar"]);
Assert.AreEqual("bar value", one["bar"]);
Assert.IsTrue(two.HasOwnProperty("bar"));
}
public void ICollectionValuesExtendedPropertiesWork()
{
var baz = new string[] { "hello", "there" };
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["baz"] = baz;
two.InheritsFrom(one);
var twoBaz = new object[] { 2, 3, 4 }; //NOTE: Integers, not strings!
two.ExtendProperty("baz", twoBaz);
var ones = one.Values;
var twos = two.Values;
Assert.IsTrue(ones.Contains(baz));
var tb = twos.ElementAt(0) as IEnumerable<object>;
Assert.AreEqual("hello there 2 3 4", String.Join(" ", tb));
}
public void InheritsFromDoesNotAddItemToChildrenOfParent()
{
var one = new HyperDictionary();
var two = new HyperDictionary();
two.InheritsFrom(one);
var oneChildrenInfo = one.GetType().GetField("children", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var oneChildren = oneChildrenInfo.GetValue(one) as IEnumerable<HyperDictionary>;
Assert.IsFalse(oneChildren.Contains(two));
}
public void InheritedPropertiesWork()
{
var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChild(two);
two["whatever"] = "big W";
Assert.AreEqual("foo value", two["foo"]);
Assert.AreEqual("bar value", two["bar"]);
Assert.AreEqual("big W", two["whatever"]);
Assert.IsFalse(two.HasOwnProperty("foo"));
Assert.IsFalse(two.HasOwnProperty("bar"));
Assert.IsFalse(two.HasOwnProperty("baz"));
Assert.IsTrue(two.HasOwnProperty("whatever"));
try
{
var whatever = one["whatever"];
Assert.Fail("Not supposed to reach here since this object should not have this property");
}
catch (IndexOutOfRangeException)
{
//Pass!
}
}
public void ICollectionValuesThreeLevelPropertiesWork()
{
var baz = new string[] { "hello", "there" };
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
var twoPrime = new HyperDictionary("two'");
var three = new HyperDictionary("three");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChildren(new HyperDictionary[] { two, twoPrime });
two.ExtendProperty("baz", new object[] { 2, 3, 4 }); //NOTE: Integers, not strings!
three.InheritsFrom(two);
three["bar"] = "three bar value";
three.ExtendProperty("baz", new object[] { "three-baz" });
var ones = one.Values;
var twos = two.Values;
var twoPrimes = twoPrime.Values;
var threes = three.Values;
//Other verification (sanity)
Assert.IsTrue(twos.Contains("foo value"));
Assert.IsTrue(twos.Contains("bar value"));
//Interesting assertions for this test
Assert.IsTrue(twoPrimes.Contains("foo value"));
Assert.IsTrue(twoPrimes.Contains("bar value"));
Assert.IsTrue(twoPrimes.Contains(baz));
Assert.IsTrue(threes.Contains("foo value"));
Assert.IsTrue(threes.Contains("three bar value"));
Assert.IsFalse(threes.Contains("bar value"));
//Elements are in order of keys added, starting with the child and then moving up
var ob = ones.ElementAt(2) as IEnumerable<object>;
var tb = twos.ElementAt(0) as IEnumerable<object>;
var tpb = twoPrimes.ElementAt(2) as IEnumerable<object>;
var thb = threes.ElementAt(1) as IEnumerable<object>;
Assert.AreEqual("hello there 2 3 4", String.Join(" ", tb));
Assert.AreEqual("hello there", String.Join(" ", ob));
Assert.AreEqual("hello there 2 3 4 three-baz", String.Join(" ", thb));
}
public void ICollectionValuesRemovedPropertiesWork()
{
//var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
//one["baz"] = baz;
two.InheritsFrom(one);
two.RemoveProperty("bar", "two's bar value"); //You can still assign a value even though you are removing it
var ones = one.Values;
var twos = two.Values;
Assert.IsTrue(ones.Contains("foo value"));
Assert.IsTrue(ones.Contains("bar value"));
//Assert.IsTrue(ones.Contains(baz));
Assert.IsTrue(twos.Contains("foo value"));
//Assert.IsTrue(twos.Contains(baz));
Assert.IsFalse(twos.Contains("two's bar value"));
Assert.IsFalse(twos.Contains("bar value"));
try
{
var bar = two["bar"];
Assert.Fail("Should not get this far since this object had this property removed");
}
catch (IndexOutOfRangeException)
{
//Pass!
}
catch (Exception)
{
Assert.Fail("Raised an exception that was not IndexOutOfRangeException");
}
}
public Pivot(HyperDictionary <TKey, TValue> data, IEnumerable <string> counters)
{
aggregatorFactories = counters.Select(AggregatorFactoryFactory.Create <TValue>).ToArray();
Init(data);
}
public void RemovedPropertiesWork()
{
var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
one["baz"] = baz;
one.AddChild(two);
two.RemoveProperty("bar");
//Other verification (sanity)
Assert.AreEqual("foo value", two["foo"]);
Assert.AreSame(baz, two["baz"]);
Assert.IsFalse(two.HasOwnProperty("foo"));
Assert.IsFalse(two.HasOwnProperty("baz"));
//Interesting assertions for this test
Assert.AreEqual("bar value", one["bar"]);
Assert.IsTrue(two.HasOwnProperty("bar"));
try
{
var bar = two["bar"];
Assert.Fail("Should not get this far since this object had this property removed");
}
catch (IndexOutOfRangeException)
{
//Pass!
}
catch (Exception)
{
Assert.Fail("Raised an exception that was not IndexOutOfRangeException");
}
}
public void ICollectionValuesOverriddenPropertiesWork()
{
//var baz = new Uri("http://blog.tonyheupel.com");
var one = new HyperDictionary("one");
var two = new HyperDictionary("two");
one["foo"] = "foo value";
one["bar"] = "bar value";
//one["baz"] = baz;
two.InheritsFrom(one);
two["bar"] = "two's bar value";
var ones = one.Values;
var twos = two.Values;
Assert.IsTrue(ones.Contains("foo value"));
Assert.IsTrue(ones.Contains("bar value"));
//Assert.IsTrue(ones.Contains(baz));
Assert.IsTrue(twos.Contains("foo value"));
//Assert.IsTrue(twos.Contains(baz));
Assert.IsTrue(twos.Contains("two's bar value"));
Assert.IsFalse(twos.Contains("bar value"));
}
