public void Constructor()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<CheckingAccount>();
assert.Extends<Account>();
assert.Constructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param<decimal>("initialBalance"),
new Param<decimal>("transactionFee")
);
assert.NonConstructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param<decimal>("initialBalance")
);
// new CheckingAccount(11.5m, -0.05m);
assert.Catch<ArgumentOutOfRangeException>(() => assert.New(11.5m, -0.05m));
#if !DEBUG
});
#endif
}
public void TestSingleFamily()
{
var assert = new TypeAssert <SingleFamily>();
assert.Extends <Home>();
assert.Property <string>(
"Address",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).DeclaredIn <Home>();
assert.Property <int>(
"YearBuilt",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).DeclaredIn <Home>();
assert.Property <decimal>(
"Price",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).DeclaredIn <Home>();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <string>("address"),
new Param <int>("yearBuilt"),
new Param <decimal>("price")
);
assert.NonConstructor(
BindingFlags.Public |
BindingFlags.Instance
);
assert.Property <decimal>(
"TotalCost",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).DeclaredIn <Home>().Override();
assert.Method <decimal>(
"GetRate",
BindingFlags.Public |
BindingFlags.Instance,
new Param <int>("numberOfPeriods")
).DeclaredIn <SingleFamily>().Override();
assert.Method <string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).DeclaredIn <SingleFamily>().Override();
}
public void TestCountClass()
{
var count = new TypeAssert <Count>();
count.Class();
count.NonAbstract();
count.Extends <Aggregator>();
count.NonPropertyAndField <int[]>("Numbers",
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.GetField |
BindingFlags.GetProperty);
count.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <int[]>("numbers"))?.Public();
count.Method <int>(
"GetValue",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty,
new Param <int>("n")
)?.Override();
}
public void TestTwoDimensionalShapeClass()
{
var assert = new TypeAssert <TwoDimensionalShape>();
assert.Extends <Shape>();
assert.Constructor(
BindingFlags.NonPublic |
BindingFlags.Instance,
new Param <int>("x"),
new Param <int>("y"),
new Param <int>("dimension1"),
new Param <int>("dimension2")
).Protected();
assert.Field <int>(
"Dimension1",
BindingFlags.Instance |
BindingFlags.NonPublic
).Protected();
assert.Field <int>(
"Dimension2",
BindingFlags.Instance |
BindingFlags.NonPublic
).Protected();
assert.Property <double>(
"Area",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).Virtual();
}
public void TestClass()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Square>();
assert.Extends<Rectangle>();
assert.Constructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param<int>("width")
);
assert.NonConstructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param<int>("width"),
new Param<int>("height")
);
assert.Property<int>(
"Width",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).DeclaredIn<EmptyTextShape>();
assert.Property<int>(
"Height",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).DeclaredIn<EmptyTextShape>();
assert.Property<string>(
"Name",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).DeclaredIn<EmptyTextShape>();
assert.Method<decimal>(
"Area",
BindingFlags.Instance |
BindingFlags.Public)
.DeclaredIn<Rectangle>();
assert.Method<decimal>(
"Perimeter",
BindingFlags.Instance |
BindingFlags.Public)
.DeclaredIn<Rectangle>();
#if !DEBUG
});
#endif
}
public void TestCircleClass()
{
var assert = new TypeAssert <Circle>();
assert.Extends <TwoDimensionalShape>();
assert.NonAbstract();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <int>("x"),
new Param <int>("y"),
new Param <int>("radius")
);
assert.ConstructorCount(1);
assert.Property <string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property <double>(
"Area",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property <int>(
"Radius",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
assert.Method <string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
assert.Field <int>(
"Dimension1",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn <TwoDimensionalShape>();
assert.Field <int>(
"Dimension2",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn <TwoDimensionalShape>();
}
public void TestThreeDimensionalShape()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<ThreeDimensionalShape>();
assert.Abstract();
assert.Extends<Shape>();
assert.Constructor(
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance,
new Param<int>("x"),
new Param<int>("y"),
new Param<int>("dimension1"),
new Param<int>("dimension2"),
new Param<int>("dimension3")
);
assert.Field<int>(
"Dimension1",
BindingFlags.Instance |
BindingFlags.NonPublic
).Protected();
assert.Field<int>(
"Dimension2",
BindingFlags.Instance |
BindingFlags.NonPublic
).Protected();
assert.Field<int>(
"Dimension3",
BindingFlags.Instance |
BindingFlags.NonPublic
).Protected();
assert.Property<double>(
"Area",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).Abstract();
assert.Property<double>(
"Volume",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).Abstract();
#if !DEBUG
});
#endif
}
public void TestThreeCalcClass()
{
var assert = new TypeAssert <ThreeCalc>();
assert.Class();
assert.Extends <TwoCalc>();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <int>("a"),
new Param <int>("b"),
new Param <int>("c")
);
assert.NonField <int>(
"_a",
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.Instance
);
assert.NonField <int>(
"_b",
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.Instance
);
assert.Field <int>(
"_c",
BindingFlags.NonPublic |
BindingFlags.Instance
).Private().ReadOnly();
assert.Method <int>(
"Calculate",
BindingFlags.Public |
BindingFlags.Instance
).Override();
assert.Method <string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
}
public void TestAverage()
{
#if !DEBUG
Assert.Multiple(() =>
{
#endif
var average = new TypeAssert<Average>();
average.Extends<Sum>();
average.Class();
average.Field<List<int>>("_count",
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.GetField)?.Private()?.ReadOnly();
average.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int[]>("numbers"));
average.Property<int>(
"Value",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
)?.Override();
average.Property<decimal>(
"DecimalValue",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
);
average.Property<int>(
"Value",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
)?.Override();
#if !DEBUG
});
#endif
}
public void Constructor()
{
var assert = new TypeAssert <SavingsAccount>();
assert.Extends <Account>();
assert.Constructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param <decimal>("initialBalance"),
new Param <decimal>("transactionFee")
);
assert.NonConstructor(
BindingFlags.Instance |
BindingFlags.Public,
new Param <decimal>("initialBalance")
);
// new SavingsAccount(11.5m, -0.05m);
assert.Catch <ArgumentOutOfRangeException>(() => assert.New(11.5m, -0.05m));
}
public void TestSum()
{
#if !DEBUG
Assert.Multiple(() =>
{
#endif
var sum = new TypeAssert<Sum>();
sum.Class();
sum.Extends<Aggregator>();
sum.NonField<List<int>>("Numbers",
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.GetField);
sum.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int[]>("numbers"));
sum.Property<int>(
"Value",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
)?.Override();
sum.Method(
"Append",
BindingFlags.Public |
BindingFlags.Instance,
new Param<Aggregator>("aggregators")
)?.Override();
#if !DEBUG
});
#endif
}
public void TestListCalcClass()
{
var assert = new TypeAssert <ListCalc>();
assert.Extends <BaseCalc>();
assert.Class();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <List <BaseCalc> >("calculations")
);
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param <int[]>("values")
{
Params = true
}
);
assert.Field <List <BaseCalc> >(
"Calculations",
BindingFlags.NonPublic |
BindingFlags.Instance
).Protected().ReadOnly();
assert.Method <int>(
"Calculate",
BindingFlags.Public |
BindingFlags.Instance
).Override();
assert.Method <string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
}
public void TestCount()
{
#if !DEBUG
Assert.Multiple(() =>
{
#endif
var count = new TypeAssert<Count>();
count.Class();
count.Extends<Aggregator>();
count.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int[]>("numbers"));
count.Property<int>(
"Value",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
)?.Override();
#if !DEBUG
});
#endif
}
public void TestCondo()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Condo>();
assert.Extends<Home>();
assert.Implements<IRental>();
assert.NonAbstract();
assert.Property<string>(
"Address",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
).DeclaredIn<Home>();
assert.Property<int>(
"YearBuilt",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).DeclaredIn<Home>();
assert.Property<decimal>(
"Price",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).DeclaredIn<Home>();
assert.Property<decimal>(
"Fee",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty);
assert.Property<string>(
"UnitNumber",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
);
assert.Property<bool>(
"IsRental",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
assert.NonConstructor(
BindingFlags.Public |
BindingFlags.Instance
);
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<string>("address"),
new Param<int>("yearBuilt"),
new Param<decimal>("price"),
new Param<string>("unitNumber"),
new Param<decimal>("fee"),
new Param<bool>("isRental") { Default = false }
);
assert.NonConstructor(
BindingFlags.Public |
BindingFlags.Instance
);
assert.Property<decimal>(
"TotalCost",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override().DeclaredIn<Condo>(); ;
assert.Method<decimal>(
"GetRate",
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("numberOfPeriods")
).Override().DeclaredIn<Condo>();
assert.Method<decimal>(
"GetMonthlyRate",
BindingFlags.Public |
BindingFlags.Instance
);
#if !DEBUG
});
#endif
}
public void TestCircle()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Circle>();
assert.Extends<TwoDimensionalShape>();
assert.NonAbstract();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("x"),
new Param<int>("y"),
new Param<int>("radius")
);
assert.ConstructorCount(1);
assert.Property<string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<double>(
"Area",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<int>(
"Radius",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
var dimension1 = assert.Field<int>(
"Dimension1",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<TwoDimensionalShape>();
var dimension2 = assert.Field<int>(
"Dimension2",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<TwoDimensionalShape>();
// var obj = new Circle(1, 2 ,3);
dynamic obj = assert.New(1, 2, 3);
Assert.AreEqual("Circle", obj.Name);
Assert.AreEqual(1, obj.X);
Assert.AreEqual(2, obj.Y);
Assert.AreEqual(3, obj.Radius);
Assert.AreEqual(3, dimension1.GetValue(obj));
Assert.AreEqual(3, dimension2.GetValue(obj));
Assert.AreEqual(28.274333882308138, obj.Area, 1E-10);
Assert.AreEqual("(1, 2) radius: 3", obj.ToString());
obj.Radius = 7;
Assert.AreEqual(7, dimension1.GetValue(obj));
Assert.AreEqual(7, dimension2.GetValue(obj));
Assert.AreEqual(153.93804002589985, obj.Area, 1E-10);
Assert.AreEqual("(1, 2) radius: 7", obj.ToString());
#if !DEBUG
});
#endif
}
public void TestSphere()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Sphere>();
assert.Extends<ThreeDimensionalShape>();
assert.NonAbstract();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("x"),
new Param<int>("y"),
new Param<int>("radius")
);
assert.ConstructorCount(1);
assert.Property<string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<double>(
"Area",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<double>(
"Volume",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<int>(
"Radius",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
var dimension1 = assert.Field<int>(
"Dimension1",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
var dimension2 = assert.Field<int>(
"Dimension2",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
var dimension3 = assert.Field<int>(
"Dimension3",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
// var obj = new Sphere(1, 2 ,3);
dynamic obj = assert.New(2, 1, 4);
Assert.AreEqual("Sphere", obj.Name);
Assert.AreEqual(2, obj.X);
Assert.AreEqual(1, obj.Y);
Assert.AreEqual(4, obj.Radius);
Assert.AreEqual(4, dimension1.GetValue(obj));
Assert.AreEqual(4, dimension2.GetValue(obj));
Assert.AreEqual(4, dimension3.GetValue(obj));
Assert.AreEqual(201.06192982974676, obj.Area, 1E-10);
Assert.AreEqual(268.08257310632899, obj.Volume, 1E-10);
Assert.AreEqual("(2, 1) radius: 4", obj.ToString());
obj.Radius = 7;
Assert.AreEqual(7, dimension1.GetValue(obj));
Assert.AreEqual(7, dimension2.GetValue(obj));
Assert.AreEqual(615.75216010359941, obj.Area, 1E-10);
Assert.AreEqual(1436.7550402417321, obj.Volume, 1E-10);
Assert.AreEqual("(2, 1) radius: 7", obj.ToString());
#if !DEBUG
});
#endif
}
public void TestCube()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Cube>();
assert.Extends<ThreeDimensionalShape>();
assert.NonAbstract();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("x"),
new Param<int>("y"),
new Param<int>("side")
);
assert.ConstructorCount(1);
assert.Property<string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<double>(
"Area",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<double>(
"Volume",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Override();
assert.Property<int>(
"Side",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
var dimension1 = assert.Field<int>(
"Dimension1",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
var dimension2 = assert.Field<int>(
"Dimension2",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
var dimension3 = assert.Field<int>(
"Dimension3",
BindingFlags.NonPublic |
BindingFlags.Instance
).DeclaredIn<ThreeDimensionalShape>();
// var obj = new Sphere(1, 2 ,3);
dynamic obj = assert.New(3, 5, 2);
Assert.AreEqual("Cube", obj.Name);
Assert.AreEqual(3, obj.X);
Assert.AreEqual(5, obj.Y);
Assert.AreEqual(2, obj.Side);
Assert.AreEqual(2, dimension1.GetValue(obj));
Assert.AreEqual(2, dimension2.GetValue(obj));
Assert.AreEqual(2, dimension3.GetValue(obj));
Assert.AreEqual(24, obj.Area, 1E-10);
Assert.AreEqual(8, obj.Volume, 1E-10);
Assert.AreEqual("(3, 5) side: 2", obj.ToString());
obj.Side = 7;
Assert.AreEqual(7, dimension1.GetValue(obj));
Assert.AreEqual(7, dimension2.GetValue(obj));
Assert.AreEqual(294, obj.Area, 1E-10);
Assert.AreEqual(343, obj.Volume, 1E-10);
Assert.AreEqual("(3, 5) side: 7", obj.ToString());
#if !DEBUG
});
#endif
}
public void TestThreeCalc()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<ThreeCalc>();
assert.Class();
assert.Extends<TwoCalc>();
assert.Implements<ICalc>();
assert.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("a"),
new Param<int>("b"),
new Param<int>("c")
);
assert.NonField<int>(
"_a",
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.Instance
);
assert.NonField<int>(
"_b",
BindingFlags.NonPublic |
BindingFlags.Public |
BindingFlags.Instance
);
assert.Field<int>(
"_c",
BindingFlags.NonPublic |
BindingFlags.Instance
).Private().ReadOnly();
assert.Method<int>(
"Calculate",
BindingFlags.Public |
BindingFlags.Instance
).Override();
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
dynamic calc;
calc = assert.New(1, 2, 3);
Assert.AreEqual(14, calc.Calculate());
Assert.AreEqual("1, 2, 3", calc.ToString());
calc = assert.New(1, 3, 5);
Assert.AreEqual(22, calc.Calculate());
Assert.AreEqual("1, 3, 5", calc.ToString());
calc = assert.New(-10, 4, -100);
Assert.AreEqual(-302, calc.Calculate());
Assert.AreEqual("-10, 4, -100", calc.ToString());
#if !DEBUG
});
#endif
}
