public void SingleValueInvalidAssignmentThrows()
{
SingleValue <int> i1 = 4;
MyFalseEquatableItem i2 = new MyFalseEquatableItem();
Assert.Throws <ConfigItem.InvalidTypeAssignmentException>(() => i1.Assign(i2));
}
public void ItemListInvalidAssignmentThrows()
{
ItemList <int> i1 = new ItemList <int>();
MyFalseEquatableItem i2 = new MyFalseEquatableItem();
Assert.Throws <ConfigItem.InvalidTypeAssignmentException>(() => i1.Assign(i2));
}
public void KeyedItemListInvalidAssignmentThrows()
{
KeyedItemList <MyKeyedInt> kil = new KeyedItemList <MyKeyedInt>();
ConfigItem ci = new MyFalseEquatableItem();
Assert.Throws <ConfigItem.InvalidTypeAssignmentException>(() => kil.Assign(ci));
}
public void DynamicMapInvalidAssignmentThrows()
{
{
DynamicMap <ConfigItem> dm = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "foo" }, { "number", (SingleValue <int>) 42 }
};
ConfigItem ci = new MyFalseEquatableItem();
Assert.Throws <ConfigItem.InvalidTypeAssignmentException>(() => dm.Assign(ci));
}
{
DynamicMap <ConfigItem> dm = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "foo" }, { "comp", new MyComposite {
ss1 = "foo"
} }
};
DynamicMap <ConfigItem> dm2 = new DynamicMap <ConfigItem> {
{ "name", (SingleItem <string>) "foo" }, { "comp", new MyComposite {
ss1 = null
} }
};
bool thrown = false;
try {
dm.Assign(dm2);
} catch (ConfigItem.InvalidChildAssignmentException e) {
thrown = true;
Assert.Single(e.ChildExceptions);
var ce = e.ChildExceptions.First();
Assert.IsType <ConfigItem.InvalidChildAssignmentException>(ce);
var ceces = ((ConfigItem.InvalidChildAssignmentException)ce).ChildExceptions;
Assert.Single(ceces);
var cecesFirst = ceces.First();
Assert.IsType <ConfigItem.InvalidTypeAssignmentException>(cecesFirst);
var cece = (ConfigItem.InvalidTypeAssignmentException)cecesFirst;
Assert.Equal(new SingleItem <string>("foo"), cece.OldItem);
Assert.Null(cece.NewItem);
}
Assert.True(thrown);
}
}
public void StaticMapInvalidAssignmentThrows()
{
{
MyComposite sm = new MyComposite();
ConfigItem ci = new MyFalseEquatableItem();
Assert.Throws <ConfigItem.InvalidTypeAssignmentException>(() => sm.Assign(ci));
}
{
MyComposite sm = new MyComposite();
MyComposite sm2 = new MyComposite {
ss1 = null, nested = new MyComposite.MyNested {
s = null
}
};
bool thrown = false;
try {
sm.Assign(sm2);
} catch (ConfigItem.InvalidChildAssignmentException e) {
thrown = true;
var childExceptions = new List <ConfigItem.InvalidAssignmentException>(e.ChildExceptions);
Assert.Equal(2, childExceptions.Count);
Assert.IsType <ConfigItem.InvalidTypeAssignmentException>(childExceptions[0]);
var ce0 = (ConfigItem.InvalidTypeAssignmentException)childExceptions[0];
Assert.Equal(new SingleItem <string>(), ce0.OldItem);
Assert.Null(ce0.NewItem);
Assert.IsType <ConfigItem.InvalidChildAssignmentException>(childExceptions[1]);
var ce1 = (ConfigItem.InvalidChildAssignmentException)childExceptions[1];
var ce1ce = new List <ConfigItem.InvalidAssignmentException>(ce1.ChildExceptions);
Assert.Single(ce1ce);
Assert.IsType <ConfigItem.InvalidTypeAssignmentException>(ce1ce[0]);
var ce1ce0 = (ConfigItem.InvalidTypeAssignmentException)ce1ce[0];
Assert.Equal(new SingleItem <string>(), ce1ce0.OldItem);
Assert.Null(ce1ce0.NewItem);
}
Assert.True(thrown);
}
}
public void StaticMapAssignmentChangesValue()
{
ConfigItem cif = new MyFalseEquatableItem();
MyComposite sm = new MyComposite {
si = 40, ss1 = "not foo", ss2 = null, nested = new MyComposite.MyNested {
x = 10, y = 20, s = "bar"
}, ci = null
};
MyComposite sm2 = new MyComposite {
si = 42, ss1 = "foo", ss2 = "bar", nested = new MyComposite.MyNested {
x = 11, y = 20, s = "barz"
}, ci = cif
};
sm.Assign(sm2);
Assert.Equal <int>(42, sm.si);
Assert.Equal("foo", sm.ss1);
Assert.Equal("bar", sm.ss2);
Assert.Equal <int>(11, sm.nested.x);
Assert.Equal("barz", sm.nested.s);
Assert.Same(cif, sm.ci);
}
public void StaticMapEqualsCallsItemEquals()
{
{
MyFalseEquatableItem e = new MyFalseEquatableItem();
MyComposite sm1 = new MyComposite {
ci = e
};
MyComposite sm2 = new MyComposite {
ci = e
};
Assert.False(sm1.Equals(sm2));
}
{
MyComposite sm1 = new MyComposite {
ci = new MyTrueEquatableItem()
};
MyComposite sm2 = new MyComposite {
ci = new MyTrueEquatableItem()
};
Assert.True(sm1.Equals(sm2));
}
}
public void DynamicMapEqualsCallsItemEquals()
{
{
MyFalseEquatableItem e = new MyFalseEquatableItem();
DynamicMap <MyFalseEquatableItem> dm1 = new DynamicMap <MyFalseEquatableItem> {
{ "eq", e }
};
DynamicMap <MyFalseEquatableItem> dm2 = new DynamicMap <MyFalseEquatableItem> {
{ "eq", e }
};
Assert.False(dm1.Equals(dm2));
}
{
DynamicMap <MyTrueEquatableItem> dm1 = new DynamicMap <MyTrueEquatableItem> {
{ "eq", new MyTrueEquatableItem() }
};
DynamicMap <MyTrueEquatableItem> dm2 = new DynamicMap <MyTrueEquatableItem> {
{ "eq", new MyTrueEquatableItem() }
};
Assert.True(dm1.Equals(dm2));
}
}
