public void TestAccessor_DynamicAccess_InstanceMethod()
{
var testClass = new PrivateTestClass();
Assert.Equal(4, testClass.TestAccessor().Dynamic.ToStringLength(2001));
Assert.Equal(7, testClass.TestAccessor().Dynamic.ToStringLength("Flubber"));
}
public void TestAccessor_NamedDelegateAccess_InstanceMethod()
{
var testClass = new PrivateTestClass();
ITestAccessor accessor = testClass.TestAccessor();
Assert.Equal(5, accessor.CreateDelegate <ToStringLength>()("25624"));
}
public void TestAccessor_DynamicAccess_PublicField()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
// If the API is public we want to access "normally", so we prevent this.
Assert.Throws <RuntimeBinderException>(() => access.PublicField = 1918);
}
public void TestAccessor_DynamicAccess_InstanceField()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
access._integer = 5;
Assert.Equal(5, access._integer);
}
public void TestAccessor_DynamicAccess_InstanceProperty()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
access.Long = 1970;
Assert.Equal(1970, access.Long);
}
public void TestAccessor_DynamicAccess_ReadOnlyInstanceField()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
access._readOnlyInteger = 7;
Assert.Equal(7, access._readOnlyInteger);
}
public void TestAccessor_FuncDelegateAccess_InstanceMethod()
{
var testClass = new PrivateTestClass();
ITestAccessor accessor = testClass.TestAccessor();
Assert.Equal(4, accessor.CreateDelegate <Func <int, int> >("ToStringLength")(2001));
Assert.Equal(7, accessor.CreateDelegate <Func <string, int> >("ToStringLength")("Flubber"));
}
public void PrivateStaticTest()
{
PrivateTestClass instance1 = new PrivateTestClass();
PrivateTestClass instance2 = new PrivateTestClass();
PrivateTestClass.StaticTest(10);
Assert.AreEqual(10, PrivateTestClass.StaticTest(20));
Assert.AreEqual(20, PrivateTestClass.StaticTest(30));
}
public void TestAccessor_FuncDelegateAccess_StaticMethod()
{
var testClass = new PrivateTestClass();
Assert.Equal(2000, testClass.TestAccessor().CreateDelegate <Func <int, int> >("AddOne")(1999));
// Hit the static class version
Assert.Equal(21, typeof(PrivateStaticTestClass).TestAccessor().CreateDelegate <Func <int, int> >("AddOne")(20));
}
public void TestAccessor_DynamicAccess_StaticMethod()
{
var testClass = new PrivateTestClass();
Assert.Equal(2, testClass.TestAccessor().Dynamic.AddOne(1));
// Hit the static class version
Assert.Equal(3, typeof(PrivateStaticTestClass).TestAccessor().Dynamic.AddOne(2));
}
public void PrivateClassTest()
{
var o = new PrivateTestClass();
var pi = CreatePI <int, PrivateTestClass>("Int");
pi.Set(o, 50);
Assert.AreEqual(50, o.Int);
Assert.AreEqual(50, pi.Get(o));
}
public void PrivateStaticTest()
{
PrivateTestClass instance1 = new PrivateTestClass();
PrivateTestClass instance2 = new PrivateTestClass();
PrivateTestClass.StaticTest( 10 );
Assert.AreEqual( 10, PrivateTestClass.StaticTest( 20 ) );
Assert.AreEqual( 20, PrivateTestClass.StaticTest( 30 ) );
}
public void TestAccessor_DynamicAccess_ObjectInstanceField()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
List <string> list = access._list;
Assert.NotNull(list);
Assert.Single(list);
Assert.Equal("42", list[0]);
}
public void PrivateInstanceTest()
{
PrivateTestClass instance1 = new PrivateTestClass();
PrivateTestClass instance2 = new PrivateTestClass();
instance1.InstanceTest(10);
Assert.AreEqual(10, instance1.InstanceTest(20));
instance2.InstanceTest(50);
Assert.AreEqual(20, instance1.InstanceTest(30));
}
public void PrivateInstanceTest()
{
PrivateTestClass instance1 = new PrivateTestClass();
PrivateTestClass instance2 = new PrivateTestClass();
instance1.InstanceTest( 10 );
Assert.AreEqual( 10, instance1.InstanceTest( 20 ) );
instance2.InstanceTest( 50 );
Assert.AreEqual( 20, instance1.InstanceTest( 30 ) );
}
public void IsImmutable_object_PrivateTestClass()
{
//Arrange
var validator = new ImmutableValidator();
object target = new PrivateTestClass();
//Act
var actual = validator.IsImmutable(target);
//Assert
Assert.True(actual);
}
public void TestAccessor_DynamicAccess_StaticProperty()
{
var testClass = new PrivateTestClass();
dynamic access = testClass.TestAccessor().Dynamic;
access.Int = 1989;
Assert.Equal(1989, access.Int);
// Now try without an instance
access = typeof(PrivateTestClass).TestAccessor().Dynamic;
access.Int = 1988;
Assert.Equal(1988, access.Int);
// Try the static class version
access = typeof(PrivateStaticTestClass).TestAccessor().Dynamic;
access.Int = 1991;
Assert.Equal(1991, access.Int);
}
public void TestAccessor_DynamicAccess_StaticField()
{
// Don't need to create an instance to access a static, can
// use typeof instead
dynamic access = typeof(PrivateTestClass).TestAccessor().Dynamic;
access.s_integer = 16;
Assert.Equal(16, access.s_integer);
// Attempt using an instance as well
var testClass = new PrivateTestClass();
access = testClass.TestAccessor().Dynamic;
access.s_integer = 18;
Assert.Equal(18, access.s_integer);
// Try the static class version
access = typeof(PrivateStaticTestClass).TestAccessor().Dynamic;
access.s_integer = 21;
Assert.Equal(21, access.s_integer);
}
