public void KeyedItemListHoldsValues()
{
{
KeyedItemList <MyKeyedInt> kil = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2)
};
Assert.Contains(new MyKeyedInt(1), kil);
Assert.Contains(new MyKeyedInt(2), kil);
Assert.Equal(1, kil["a"]);
Assert.Equal(2, kil["b"]);
}
{
MyComposite sm1 = new MyComposite {
si = 42, ss1 = "foo", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
MyComposite sm2 = new MyComposite {
si = 42, ss1 = "bar", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
KeyedItemList <MyComposite> kil = new KeyedItemList <MyComposite> {
sm1, sm2
};
Assert.Equal(sm1, kil["foo"]);
Assert.Same(sm1, kil["foo"]);
Assert.Equal(sm2, kil["bar"]);
Assert.Same(sm2, kil["bar"]);
Assert.Throws <System.Collections.Generic.KeyNotFoundException>(() => kil["ThisKeyShouldNotExist"]);
}
}
public void DynamicMapHoldsValues()
{
{
DynamicMap <SingleValue <int> > dm = new DynamicMap <SingleValue <int> > {
{ "a", 3 }, { "b", 4 }
};
Assert.Equal((SingleValue <int>) 3, dm["a"]);
Assert.Equal((SingleValue <int>) 4, dm["b"]);
}
{
DynamicMap <SingleItem <string> > dm = new DynamicMap <SingleItem <string> > {
{ "a", "foo" }, { "b", "bar" }
};
Assert.Equal((SingleItem <string>) "foo", dm["a"]);
Assert.Equal((SingleItem <string>) "bar", dm["b"]);
}
{
MyComposite sm = new MyComposite {
si = 42, ss1 = "foo", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
DynamicMap <ConfigItem> dm = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "foo" }, { "number", (SingleValue <int>) 42 }, { "smap", sm }
};
Assert.Equal("foo", (SingleItem <string>)dm["name"]);
Assert.Equal <int>(42, (SingleValue <int>)dm["number"]);
Assert.Same(sm, dm["smap"]);
Assert.Throws <System.Collections.Generic.KeyNotFoundException>(() => dm["ThisKeyShouldNotExist"]);
}
}
public void Test_Composite()
{
int result = -1;
MyComposite c1 = new MyComposite();
c1.Add(new MyCompositeLeaf(1));
c1.Add(new MyCompositeLeaf(2));
MyComposite c2 = new MyComposite();
c2.Add(new MyCompositeLeaf(3));
c2.Add(new MyCompositeLeaf(1));
MyComposite c0 = new MyComposite();
c0.Add(c1);
c0.Add(new MyCompositeLeaf(5));
c0.Add(c2);
result = c0.Operation("param0");
Assert.AreEqual(12, result);
// access to subchildren
result = c0.GetChild(0).Operation("param1");
Assert.AreEqual(3, result);
// invalid child
Assert.IsNull(c0.GetChild(-1));
Assert.IsNull(c0.GetChild(5));
}
public void DynamicMapAssignmentChangesValue()
{
MyComposite sm1 = new MyComposite {
si = 42, ss1 = "foo", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
MyComposite sm2 = new MyComposite {
si = 43, ss1 = "foo", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
DynamicMap <ConfigItem> dm = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "foo" }, { "number", (SingleValue <int>) 42 }, { "smap", sm1 }
};
DynamicMap <ConfigItem> dm2 = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "bar" }, { "number", (SingleValue <int>) 40 }, { "smap", sm2 }
};
dm.Assign(dm2);
Assert.Equal("bar", (SingleItem <string>)dm["name"]);
Assert.Equal <int>(40, (SingleValue <int>)dm["number"]);
Assert.Equal <int>(43, ((MyComposite)dm["smap"]).si);
Assert.Same(sm1, dm["smap"]);
}
public void AddChild_ShouldValidate()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root);
Assert.Throws <ArgumentNullException>(() => root.Children.Add(null));
Assert.Throws <ArgumentException>(() => root.Children.Add(child), Resources.BELONGING_ITEM);
}
public void Dispose_ShouldRemoveTheChildFromTheParentsChildrenList()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root);
new MyComposite(root); // harmadik
Assert.That(root.Children.Count, Is.EqualTo(2));
child.Dispose();
Assert.That(root.Children.Count, Is.EqualTo(1));
}
public async Task DisposeAsync_ShouldFreeTheChildrenRecursively()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root),
grandChild = new MyComposite(child);
await root.DisposeAsync();
Assert.Throws <ObjectDisposedException>(grandChild.Dispose);
Assert.Throws <ObjectDisposedException>(child.Dispose);
}
public void Dispose_ShouldFreeTheChildrenRecursively()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root),
grandChild = new MyComposite(child);
root.Dispose();
Assert.Throws <ObjectDisposedException>(grandChild.Dispose);
Assert.Throws <ObjectDisposedException>(child.Dispose);
}
public void ContainsChild_ShouldDoWhatItsNameSuggests()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite();
Assert.That(root.Children.Contains(child), Is.False);
root.Children.Add(child);
Assert.That(root.Children.Contains(child));
}
public void Parent_ShouldNotBeSetDirectly()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root);
Assert.That(child.Parent, Is.EqualTo(root));
Assert.Throws <InvalidOperationException>(() => child.Parent = null, Resources.CANT_SET_PARENT);
root.Children.Remove(child);
Assert.That(child.Parent, Is.Null);
}
public void RemoveChild_ShouldValidate()
{
IMyComposite
root = new MyComposite(),
child = new MyComposite(root);
Assert.Throws <ArgumentNullException>(() => root.Children.Remove(null));
Assert.That(() => root.Children.Remove(new MyComposite()), Is.False);
//
// Nem lett felszabaditva.
//
Assert.DoesNotThrow(child.Dispose);
Assert.That(root.Children.Count, Is.EqualTo(0));
}
public string SayHi(MyComposite customParam)
{
// NOTE! Business logic is properly routed from service layer to business logic layer
return(BusinessLogicHandler.ADMCompletedDemoService_SayHi(customParam));
}
public void KeyedItemListEqualsWorks()
{
{
KeyedItemList <MyKeyedInt> kil1 = new KeyedItemList <MyKeyedInt> {
};
KeyedItemList <MyKeyedInt> kil2 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1)
};
Assert.NotEqual(kil1, kil2);
Assert.NotEqual(kil2, kil1);
Assert.False(kil1.Equals(kil2));
Assert.False(kil2.Equals(kil1));
}
{
KeyedItemList <MyKeyedInt> kil1 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2)
};
KeyedItemList <MyKeyedInt> kil2 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1)
};
Assert.NotEqual(kil1, kil2);
Assert.False(kil1.Equals(kil2));
}
{
KeyedItemList <MyKeyedInt> kil1 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2)
};
KeyedItemList <MyKeyedInt> kil2 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2), new MyKeyedInt("c", 3)
};
Assert.NotEqual(kil1, kil2);
Assert.False(kil1.Equals(kil2));
}
{
MyComposite sm1 = new MyComposite {
si = 42, ss1 = "foo", ss2 = "key is foo", nested = null, ci = null
};
MyComposite sm2 = new MyComposite {
si = 43, ss1 = "bar", ss2 = "key is bar", nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
KeyedItemList <MyComposite> kil1 = new KeyedItemList <MyComposite> {
sm1, sm2
};
KeyedItemList <MyComposite> kil2 = new KeyedItemList <MyComposite> {
sm2, sm1
};
Assert.Equal(kil1, kil2);
Assert.True(kil1.Equals(kil2));
}
{
KeyedItemList <MyKeyedInt> kil1 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2)
};
KeyedItemList <MyKeyedInt> kil2 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("c", 3), new MyKeyedInt("d", 4)
};
Assert.NotEqual(kil1, kil2);
Assert.False(kil1.Equals(kil2));
}
{
KeyedItemList <MyKeyedInt> kil1 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 1), new MyKeyedInt("b", 2)
};
KeyedItemList <MyKeyedInt> kil2 = new KeyedItemList <MyKeyedInt> {
new MyKeyedInt("a", 2), new MyKeyedInt("b", 1)
};
Assert.NotEqual(kil1, kil2);
Assert.False(kil1.Equals(kil2));
}
{
KeyedItemList <MyKeyedInt> kil = new KeyedItemList <MyKeyedInt>();
Assert.False(kil.Equals(null));
Assert.False(kil.Equals((KeyedItemList <MyKeyedInt>)null));
Assert.False(kil.Equals((ConfigItem)null));
}
}
protected override void TestComposite(MyComposite composite)
{
composite.TestSideEffectAttribute();
Assert.IsTrue(_sideEffectInvoked, "Side effect must've been invoked.");
Assert.IsTrue(_mixinInvoked, "Mixin must've been invoked.");
}
protected override void TestComposite(MyComposite composite)
{
composite.TestConcernAttribute();
Assert.IsTrue(_concernInvoked, "Concern must've been invoked.");
Assert.IsTrue(_mixinInvoked, "Mixin must've been invoked.");
}
protected override void TestComposite(MyComposite composite)
{
composite.TestStructureAttribute();
Assert.IsTrue(_mixinInvoked);
}
