public void Debit()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<CheckingAccount>();
assert.Method<bool>(
"Debit",
BindingFlags.Instance |
BindingFlags.Public,
new Param<decimal>("amount")
).Override();
decimal fee = 3.5m;
dynamic o;
// new CheckingAccount(1000m, fee);
o = assert.New(1000m, fee);
Assert.IsTrue(o.Debit(500m));
Assert.AreEqual(496.5m, o.Balance);
Assert.IsFalse(o.Debit(494.0m));
Assert.AreEqual(496.5m, o.Balance);
#if !DEBUG
});
#endif
}
public void Debit()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<SavingsAccount>();
assert.Method<bool>(
"Debit",
BindingFlags.Instance |
BindingFlags.Public,
new Param<decimal>("amount")
).Override();
decimal rate = 0.035m;
dynamic o;
// new SavingsAccount(1000m, rate);
o = assert.New(1000m, rate);
Assert.IsTrue(o.Debit(491m));
Assert.AreEqual(509m, o.Balance);
Assert.IsFalse(o.Debit(509.01m));
Assert.AreEqual(509m, o.Balance);
Assert.IsTrue(o.Debit(509m));
Assert.AreEqual(0m, o.Balance);
#if !DEBUG
});
#endif
}
public void Debit()
{
#if !DEBUG
Assert.Multiple(() =>
{
#endif
var assert = new TypeAssert<Account>();
var p = assert.Method<bool>(
"Debit",
BindingFlags.Instance |
BindingFlags.Public,
new Param<decimal>("amount")
).Virtual();
dynamic account;
account = assert.New(100m);
Assert.AreEqual(100m, account.Balance);
bool debit = account.Debit(23.45m);
Assert.AreEqual(76.55m, account.Balance);
Assert.IsTrue(debit);
debit = account.Debit(76.56m);
Assert.IsFalse(debit);
Assert.AreEqual(76.55m, account.Balance);
assert.Catch<ArgumentOutOfRangeException>(() => account.Debit(-0.01m));
Assert.AreEqual(76.55m, account.Balance);
#if !DEBUG
});
#endif
}
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 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 TestAggregator()
{
#if !DEBUG
Assert.Multiple(() =>
{
#endif
var aggregator = new TypeAssert<Aggregator>();
aggregator.Class();
aggregator.Abstract();
aggregator.Field<List<int>>("Numbers",
BindingFlags.NonPublic |
BindingFlags.Instance |
BindingFlags.GetField)?.Protected()?.ReadOnly();
aggregator.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<int[]>("numbers"));
aggregator.Property<int>(
"Value",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
)?.Abstract();
aggregator.Method(
"Append",
BindingFlags.Public |
BindingFlags.Instance,
new Param<Aggregator>("aggregators")
)?.Virtual();
aggregator.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.DeclaredOnly
);
#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 TestShape()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Shape>();
assert.Abstract();
assert.Property<int>(
"X",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Property<int>(
"Y",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Property<string>(
"Name",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Constructor(
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic,
new Param<int>("x"),
new Param<int>("y")
);
assert.Property<string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Abstract();
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
#if !DEBUG
});
#endif
}
public void Swap()
{
_test.Method(
"Swap",
BindingFlags.Public | BindingFlags.Instance,
new Param <int>("a")
{
Ref = true
},
new Param <int>("b")
{
Ref = true
}
);
int a = 100;
int b = 200;
_object.Swap(ref a, ref b);
Assert.AreEqual(200, a, "the second argument should be swapped to the first argument");
Assert.AreEqual(100, b, "the first argument should be swapped to the second argument");
}
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 CalculateInterest()
{
var assert = new TypeAssert <SavingsAccount>();
assert.Method <decimal>(
"CalculateInterest",
BindingFlags.Instance |
BindingFlags.Public
).DeclaredIn <SavingsAccount>();
dynamic o;
decimal rate = 0.035m;
o = assert.New(1234m, rate);
Assert.AreEqual(43.19m, o.CalculateInterest());
}
public void TestBaseCalcClass()
{
var assert = new TypeAssert <BaseCalc>();
assert.Constructor(
BindingFlags.NonPublic |
BindingFlags.Instance
).Protected();
assert.Method <int>(
"Calculate",
BindingFlags.Public |
BindingFlags.DeclaredOnly |
BindingFlags.Instance
).Virtual();
}
public void TestShapeClass()
{
var assert = new TypeAssert <Shape>();
assert.Constructor(
BindingFlags.Instance |
BindingFlags.NonPublic,
new Param <int>("x"),
new Param <int>("y")
).Protected();
assert.Property <int>(
"X",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Property <int>(
"Y",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Property <string>(
"Name",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty
);
assert.Property <string>(
"Name",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
).Virtual();
assert.Method <string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
}
public void TestICalc()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<ICalc>();
assert.Interface();
assert.Method<int>(
"Calculate",
BindingFlags.Public |
BindingFlags.DeclaredOnly |
BindingFlags.Instance
);
#if !DEBUG
});
#endif
}
public void TestCompute()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Shape>();
var compute = assert.Method(
"Compute",
BindingFlags.Static |
BindingFlags.Public,
new Param<Shape[]>("shapes")
);
Shape[] shapes = new Shape[4];
// shapes[0] = new Circle(22, 88, 4);
shapes[0] = (Shape)Activator.CreateInstance(typeof(Circle), 22, 88, 4);
// shapes[1] = new Cube(79, 61, 8);
shapes[1] = (Shape)Activator.CreateInstance(typeof(Cube), 79, 61, 8);
// shapes[2] = new Sphere(8, 89, 2);
shapes[2] = (Shape)Activator.CreateInstance(typeof(Sphere), 8, 89, 2);
// shapes[3] = new Square(71, 96, 10);
shapes[3] = (Shape)Activator.CreateInstance(typeof(Square), 71, 96, 10);
// Shape.Compute(shapes);
Action app = () => compute.Invoke(null, new[] { shapes });
string actual = app.Run();
actual.Assert(
"Circle",
"(22, 88) radius: 4",
"50.26548246",
"Cube",
"(79, 61) side: 8",
"384",
"512",
"Sphere",
"(8, 89) radius: 2",
"50.26548246",
"33.51032164",
"Square",
"(71, 96) side: 10",
"100"
);
#if !DEBUG
});
#endif
}
public void TestHomeShow()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var home = new TypeAssert<Home>();
var show = home.Method(
"Show",
BindingFlags.Public |
BindingFlags.Static,
new Param<Home[]>("homes")
{
Params = true
}
);
var condo = new TypeAssert<Condo>();
var singleFamily = new TypeAssert<SingleFamily>();
dynamic condo1, condo2;
dynamic[] homes = {
singleFamily.New("Two Main Street", 1800, 100_000m),
condo1 = condo.New("One Main Street", 1900, 100_000m, "A", 2000m, false),
condo2 = condo.New("Three Main Street", 2000, 200_000m, "A", 1000m, true),
singleFamily.New("Four Main Street", 2010, 300_000m)
};
// Asserting: Home.Show(homes);
Action showApp = () => show.Invoke(null, new object[] { homes.Cast<Home>().ToArray() });
var actual = showApp.Run();
actual.Assert(
"Two Main Street 1800 $100,000.00",
"One Main Street 1900 A $102,000.00",
"One Main Street 1900 A $425.00",
"Three Main Street 2000 A $201,000.00",
"Three Main Street 2000 A $837.50",
"Four Main Street 2010 $300,000.00"
);
Assert.IsFalse(condo1.IsRental, "The rental option must be reverted");
Assert.IsTrue(condo2.IsRental, "The rental option must be reverted");
#if !DEBUG
});
#endif
}
public void Credit()
{
var assert = new TypeAssert <CheckingAccount>();
assert.Method <bool>(
"Credit",
BindingFlags.Instance |
BindingFlags.Public,
new Param <decimal>("amount")
).Override();
decimal fee = 3.5m;
dynamic o;
// new CheckingAccount(1000m, fee);
o = assert.New(1000m, fee);
Assert.IsTrue(o.Credit(500m));
Assert.AreEqual(1496.5m, o.Balance);
Assert.IsFalse(o.Credit(2m));
Assert.AreEqual(1496.5m, o.Balance);
}
public void Credit()
{
var assert = new TypeAssert <Account>();
var p = assert.Method <bool>(
"Credit",
BindingFlags.Instance |
BindingFlags.Public,
new Param <decimal>("amount")
).Virtual();
dynamic account;
account = assert.New(100m);
Assert.AreEqual(100m, account.Balance);
bool credit = account.Credit(123.45m);
Assert.AreEqual(223.45m, account.Balance);
Assert.IsTrue(credit);
assert.Catch <ArgumentOutOfRangeException>(() => account.Credit(-0.45m));
Assert.AreEqual(223.45m, account.Balance);
}
public void Credit()
{
var assert = new TypeAssert <SavingsAccount>();
assert.Method <bool>(
"Credit",
BindingFlags.Instance |
BindingFlags.Public,
new Param <decimal>("amount")
).Override();
decimal rate = 0.035m;
dynamic o;
// new SavingsAccount(1000m, rate);
o = assert.New(1000m, rate);
Assert.IsTrue(o.Credit(500m));
Assert.AreEqual(1500m, o.Balance);
Assert.IsTrue(o.Credit(2m));
Assert.AreEqual(1502m, o.Balance);
}
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 TestIRental()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<IRental>();
assert.Method<decimal>(
"GetMonthlyRate",
BindingFlags.Public |
BindingFlags.Instance
);
assert.Property<bool>(
"IsRental",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
);
#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 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
}
public void TestSingleFamily()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<SingleFamily>();
assert.Extends<Home>();
assert.NotImplements<IRental>();
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();
#if !DEBUG
});
#endif
}
public void TestHome()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var assert = new TypeAssert<Home>();
assert.Abstract();
assert.Property<string>(
"Address",
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.GetProperty);
assert.Property<int>(
"YearBuilt",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
);
assert.Property<decimal>(
"Price",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty
);
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
).Virtual();
assert.Method<decimal>(
"GetRate",
BindingFlags.Public |
BindingFlags.Instance,
new Param<int>("numberOfPeriods")
).Abstract();
assert.Method<string>(
"ToString",
BindingFlags.Public |
BindingFlags.Instance
).Override();
#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 decimal Hypotenuse(decimal a, decimal b)
{
_test.Method <decimal>(
"Hypotenuse",
BindingFlags.Public | BindingFlags.Instance,
new Param <decimal>("a"),
new Param <decimal>("b")
);
decimal c = _object.Hypotenuse(a, b);
return(c);
}
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 TestInvoiceClass()
{
#if !DEBUG
Assert.Multiple(() => {
#endif
var invoiceClass = new TypeAssert<Invoice>();
var partNumber = invoiceClass.Property<string>("PartNumber",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
).AutoImplemented();
var partDescription = invoiceClass.Property<string>("PartDescription",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
).AutoImplemented();
var quantityField = invoiceClass.Field<int>("_quantity",
BindingFlags.NonPublic |
BindingFlags.Instance
);
var pricePerItemField = invoiceClass.Field<decimal>("_pricePerItem",
BindingFlags.NonPublic |
BindingFlags.Instance
);
var quantity = invoiceClass.Property<int>("Quantity",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
).NotAutoImplemented();
var pricePerItem = invoiceClass.Property<decimal>("PricePerItem",
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.GetProperty |
BindingFlags.SetProperty
).NotAutoImplemented();
var constructor = invoiceClass.Constructor(
BindingFlags.Public |
BindingFlags.Instance,
new Param<string>("partNumber"),
new Param<string>("partDescription"),
new Param<int>("quantity"),
new Param<decimal>("price"));
var getInvoiceAmount = invoiceClass.Method<decimal>(
"GetInvoiceAmount",
BindingFlags.Public |
BindingFlags.Instance);
// field testing
Invoice invoice = invoiceClass.New("1234", "Hammer", 2, 14.95m);
Assert.AreEqual(2, quantityField.GetValue(invoice), "Initial Quantity");
Assert.AreEqual(14.95m, pricePerItemField.GetValue(invoice), "Initial price per item");
#if !DEBUG
});
#endif
}
