protected override void VerifyDeserialized <TValueType>(TValueType deserializedValue, TValueType expectedValue, MessageSerializedPropertyInfo propertyInfo, byte[] valueArray)
{
// The "Kind" property after deserialization is "Unspecified" so we need to ignore that part
TestSubClass deserializedSubClass = deserializedValue as TestSubClass;
TestSubClass expectedSubClass = expectedValue as TestSubClass;
Assert.That(deserializedSubClass, Is.Not.Null, "DeserializedTestSubClass");
Assert.That(expectedSubClass, Is.Not.Null, "ExpectedTestSubClass");
Assert.That(expectedSubClass.Length, Is.Not.EqualTo(0), "Length 0");
Assert.That(deserializedSubClass.Length, Is.EqualTo(expectedSubClass.Length), "Length");
Assert.That(deserializedSubClass.Meters.Count, Is.EqualTo(expectedSubClass.Meters.Count), "MetersCount");
for (int index = 0; index < deserializedSubClass.Meters.Count; ++index)
{
TestSubClass.MetersBlob deserializedMeterBlob = deserializedSubClass.Meters[index];
TestSubClass.MetersBlob expectedMeterBlob = expectedSubClass.Meters[index];
Assert.That(deserializedMeterBlob.MeterLength, Is.EqualTo(expectedMeterBlob.MeterLength), "MeterLength");
Assert.That(deserializedMeterBlob.MeterNumber, Is.EqualTo(expectedMeterBlob.MeterNumber), "MeterNumber");
Assert.That(deserializedMeterBlob.BcdMeterValue, Is.EqualTo(expectedMeterBlob.BcdMeterValue), "BcdMeterValue");
}
Assert.That(deserializedSubClass.SomeSubClass.Field1, Is.EqualTo(expectedSubClass.SomeSubClass.Field1), "Field1");
Assert.That(deserializedSubClass.SomeSubClass.Field2, Is.EqualTo(expectedSubClass.SomeSubClass.Field2), "Field2");
}
public void How_to_get_the_declared_class_name_when_calling_a_Static_method()
{
var className = TestClass.GetClassNameWhenCallingStaticMethod();
var subClassName = TestSubClass.GetClassNameWhenCallingStaticMethod();
className.ShouldBe(typeof(TestClass).Name);
subClassName.ShouldBe(typeof(TestSubClass).Name);
}
public void Test_GetValue_VirtualProperty_CalledOnBaseClass() {
// Arrange
TestBaseClass instance = new TestSubClass();
string testValue = "some test value";
instance.VirtualTestProperty = testValue;
Munger munger = new Munger("VirtualTestProperty");
// Act
string value = munger.GetValue(instance) as string;
// Assert
Assert.AreEqual(testValue, value);
}
public void Test_PutValue_DottedAspect_Success()
{
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("This.This.VirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Assert
Assert.AreEqual(testValue, instance.VirtualTestProperty);
}
public void Test_PutValue_NonVirtualProperty_CalledOnSubClass()
{
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("NonVirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Assert
Assert.AreEqual(testValue, instance.NonVirtualTestProperty);
Assert.IsTrue(instance.subClassPropertyModified);
}
public void Test_GetValue_NonVirtualProperty_CalledOnSubClass()
{
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
instance.NonVirtualTestProperty = testValue;
Munger munger = new Munger("NonVirtualTestProperty");
// Act
string value = munger.GetValue(instance) as string;
// Assert
Assert.AreEqual(testValue, value);
}
public void Test_PutValue_DottedAspect_CantModifyReadOnlyProperty()
{
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
string testValue2 = "some test value2";
Munger munger = new Munger("This.This.ReadOnlyProperty");
instance.SetReadOnlyProperty(testValue);
Assert.AreEqual(testValue, instance.ReadOnlyProperty);
// Act
munger.PutValue(instance, testValue2);
// Assert
Assert.AreEqual(testValue, instance.ReadOnlyProperty);
}
public void CreateAttachmentInSubCouchDocumentClass()
{
// Arrange
TestSubClass tsc = new TestSubClass { TESTVAL = "Hello" };
tsc = _db.CreateDocument(tsc, new Result<TestSubClass>()).Wait();
// Act
var attachment = Encoding.UTF8.GetBytes("test");
using (MemoryStream ms = new MemoryStream(
Encoding.UTF8.GetBytes("This is a text document")))
{
_db.AddAttachment(tsc.Id, ms, "test_upload.txt");
}
tsc = _db.GetDocument(tsc.Id, new Result<TestSubClass>()).Wait();
// Assert
Assert.IsTrue(tsc.HasAttachment);
}
public void ForEach_applies_only_to_specified_subtype()
{
var t1 = new TestSubClass();
var t2 = new TestSubClass();
_list.Add(new TestBaseClass());
_list.Add(new TestBaseClass());
_list.Add(t1);
_list.Add(new TestBaseClass());
_list.Add(new OtherSubClass());
_list.Add(new TestBaseClass());
_list.Add(t2);
_list.ForEach(_action);
_action.Received(1).Invoke(t1);
_action.Received(1).Invoke(t2);
_action.DidNotReceive().Invoke(Arg.Is<TestSubClass>(x => !x.Equals(t1) && !x.Equals(t2)));
}
static void Main()
{
TestClass obj = new TestClass();
TestSubClass subObj = new TestSubClass();
OtherSubClass otherObj = new OtherSubClass();
obj.TestMethod();
subObj.TestMethod();
otherObj.TestMethod();
try {
RedirectionHelper.RedirectCalls(typeof(TestSubClass).GetMethod("TestMethod"), typeof(DetourClass).GetMethod("TestMethod"));
obj.TestMethod();
subObj.TestMethod();
otherObj.TestMethod();
} catch (Exception e) {
Console.Out.WriteLine(e);
}
}
static void Main()
{
TestClass obj = new TestClass();
TestSubClass subObj = new TestSubClass();
OtherSubClass otherObj = new OtherSubClass();
obj.TestMethod();
subObj.TestMethod();
otherObj.TestMethod();
try {
RedirectionHelper.RedirectCalls(typeof(TestSubClass).GetMethod("TestMethod"), typeof(DetourClass).GetMethod("TestMethod"));
obj.TestMethod();
subObj.TestMethod();
otherObj.TestMethod();
} catch (Exception e) {
Console.Out.WriteLine(e);
}
}
public void GetByIdTest()
{
// When Id is set the object is returned
TestSubClass testSubClass = new TestSubClass {
id = "theId", name = "theName"
};
TestClass theObject = new TestClass {
PropertyInt = 7, PropertyString = "Test", Sub = testSubClass
};
TestSubClass actual = ObjectLookupHelper.GetById <TestSubClass>(theObject, testSubClass.id);
Assert.AreEqual(theObject.Sub, actual);
// Id is null, returns null
testSubClass = new TestSubClass {
id = null, name = "theName"
};
theObject = new TestClass {
PropertyInt = 7, PropertyString = "Test", Sub = testSubClass
};
actual = ObjectLookupHelper.GetById <TestSubClass>(theObject, testSubClass.id);
Assert.AreEqual(null, actual);
// Id is set in Subs, that Sub is returned
testSubClass = new TestSubClass {
id = "theId", name = "theName"
};
theObject = new TestClass {
PropertyInt = 7, PropertyString = "Test", Sub = null, Subs = new TestSubClass[] { testSubClass }
};
actual = ObjectLookupHelper.GetById <TestSubClass>(theObject, testSubClass.id);
Assert.AreEqual(theObject.Subs[0], actual);
// This time the Id is not found
testSubClass = new TestSubClass {
id = "theId", name = "theName"
};
theObject = new TestClass {
PropertyInt = 7, PropertyString = "Test", Sub = null, Subs = new TestSubClass[] { testSubClass }
};
actual = ObjectLookupHelper.GetById <TestSubClass>(theObject, "invalid Id");
Assert.AreEqual(null, actual);
}
public void Test_PutValue_NonVirtualProperty_CalledOnBaseClass()
{
// Arrange
TestBaseClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("NonVirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Munger acts on the runtime type of the instance, so it (correctly)
// calls the subclass' version of this property. The compiler
// uses the declared type of the instance, so instance.NonVirtualTestProperty
// returns null, which is correct but perhaps unexpected.
// Assert
Assert.AreEqual(null, instance.NonVirtualTestProperty);
Assert.AreEqual(testValue, (instance as TestSubClass).NonVirtualTestProperty);
Assert.IsTrue((instance as TestSubClass).subClassPropertyModified);
}
public void ShouldCreateAttachmentInSubCouchDocumentClass()
{
var db = client.GetDatabase(baseDatabase);
TestSubClass tsc = new TestSubClass {
TESTVAL = "Hello"
};
tsc = db.CreateDocument(tsc, new Result <TestSubClass>()).Wait();
var attachment = Encoding.UTF8.GetBytes("test");
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes("This is a text document")))
{
db.AddAttachment(tsc.Id, ms, "test_upload.txt");
}
tsc = db.GetDocument(tsc.Id, new Result <TestSubClass>()).Wait();
Assert.IsTrue(tsc.HasAttachment);
}
public void Test_PutValue_NonVirtualProperty_CalledOnBaseClass() {
// Arrange
TestBaseClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("NonVirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Munger acts on the runtime type of the instance, so it (correctly)
// calls the subclass' version of this property. The compiler
// uses the declared type of the instance, so instance.NonVirtualTestProperty
// returns null, which is correct but perhaps unexpected.
// Assert
Assert.AreEqual(null, instance.NonVirtualTestProperty);
Assert.AreEqual(testValue, (instance as TestSubClass).NonVirtualTestProperty);
Assert.IsTrue((instance as TestSubClass).subClassPropertyModified);
}
public void TestInvokeMemberField()
{
Type type = typeof(TestClass);
Type subType = typeof(TestSubClass);
TestSubClass targetSub = new TestSubClass();
TestClass target = targetSub;
// 测试父类。
// Default
Assert.AreEqual(target.TestField, type.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(target.TestField2, type.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(target.TestField3, type.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(target.TestField4, type.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
// Explicit
Assert.AreEqual(target.TestField, type.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(target.TestField2, type.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(target.TestField3, type.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(target.TestField4, type.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
// 测试子类。
// Default
Assert.AreEqual(targetSub.TestField, subType.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(targetSub.TestField2, subType.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(targetSub.TestField3, subType.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
Assert.AreEqual(targetSub.TestField4, subType.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.Default,
target, new object[0]));
// Explicit
Assert.AreEqual(targetSub.TestField, subType.InvokeMember("TestField", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(targetSub.TestField2, subType.InvokeMember("TestField2", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(targetSub.TestField3, subType.InvokeMember("TestField3", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
Assert.AreEqual(targetSub.TestField4, subType.InvokeMember("TestField4", BindingFlags.GetField, PowerBinder.Explicit,
target, new object[0]));
// 测试设置父类字段。
// Default
type.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.Default, target, new object[] { "TestClass0" });
Assert.AreEqual("TestClass0", target.TestField);
type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default, target, new object[] { (short)20 });
Assert.AreEqual((short)20, target.TestField2);
AssertExt.ThrowsException(() => type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default,
target, new object[] { 20 }), typeof(ArgumentException), typeof(InvalidCastException));
type.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Default, target, new object[] { 200 });
Assert.AreEqual(200L, target.TestField3);
type.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Default, target, new object[] { "TestClass44" });
Assert.AreEqual("TestClass44", target.TestField4);
// Explicit
type.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { "TestClass0" });
Assert.AreEqual("TestClass0", target.TestField);
type.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 20 });
Assert.AreEqual((short)20, target.TestField2);
type.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 200 });
Assert.AreEqual(200L, target.TestField3);
type.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { "TestClass44" });
Assert.AreEqual("TestClass44", target.TestField4);
// 测试设置子类字段。
// Default
subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.Default, target,
new object[] { "TestSubClass0" });
Assert.AreEqual("TestSubClass0", targetSub.TestField);
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default, target, new object[] { 21 });
Assert.AreEqual(21, targetSub.TestField2);
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Default, target, new object[] { 201 });
Assert.AreEqual(201, targetSub.TestField3);
subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Default, target, new object[] { 202 });
Assert.AreEqual(202, targetSub.TestField4);
// Explicit
subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.Explicit, target,
new object[] { "TestSubClass0" });
Assert.AreEqual("TestSubClass0", targetSub.TestField);
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 21 });
Assert.AreEqual(21, targetSub.TestField2);
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 201 });
Assert.AreEqual(201, targetSub.TestField3);
subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 202 });
Assert.AreEqual(202, targetSub.TestField4);
// 测试设置子类和父类字段。
// Default
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default, target, new object[] { (short)22 });
Assert.AreEqual((short)22, target.TestField2);
AssertExt.ThrowsException(() => subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default,
target, new object[] { 23L }),
typeof(MissingFieldException), typeof(ArgumentException), typeof(InvalidCastException));
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Default, target, new object[] { 202L });
Assert.AreEqual(202L, target.TestField3);
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Default, target, new object[] { (short)203 });
Assert.AreEqual(203, targetSub.TestField3);
subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Default, target,
new object[] { "TestClass00" });
Assert.AreEqual("TestClass00", target.TestField4);
// Explicit
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { (short)22 });
Assert.AreEqual((short)22, target.TestField2);
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 23L });
Assert.AreEqual(23, targetSub.TestField2);
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { 202L });
Assert.AreEqual(202L, target.TestField3);
subType.InvokeMember("TestField3", BindingFlags.SetField, PowerBinder.Explicit, target, new object[] { (short)203 });
Assert.AreEqual(203, targetSub.TestField3);
subType.InvokeMember("TestField4", BindingFlags.SetField, PowerBinder.Explicit, target,
new object[] { "TestClass00" });
Assert.AreEqual("TestClass00", target.TestField4);
// 测试强制类型转换。
// Default
AssertExt.ThrowsException(() =>
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Default, target,
new object[] { Tristate.True }),
typeof(MissingFieldException), typeof(ArgumentException), typeof(InvalidCastException));
// Explicit
subType.InvokeMember("TestField2", BindingFlags.SetField, PowerBinder.Explicit, target,
new object[] { Tristate.True });
Assert.AreEqual((int)Tristate.True, targetSub.TestField2);
AssertExt.ThrowsException(() =>
subType.InvokeMember("TestField", BindingFlags.SetField, PowerBinder.Explicit, target,
new object[] { 22 }), typeof(MissingFieldException));
}
public void TestInvokeMemberMethod()
{
Type type = typeof(TestSubClass);
BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod;
BindingFlags bindingOptFlags = bindingFlags | BindingFlags.OptionalParamBinding;
// 测试完整的调用。
Assert.AreEqual(TestSubClass.TestMethod(),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[0]));
Assert.AreEqual(TestSubClass.TestMethod(10),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10 }));
Assert.AreEqual(TestSubClass.TestMethod(10),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Explicit, null,
new object[] { 10 }));
Assert.AreEqual(TestSubClass.TestMethod(10, 20),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10, 20 }));
Assert.AreEqual(TestSubClass.TestMethod(10, 20),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Explicit, null,
new object[] { 10, 20 }));
Assert.AreEqual(TestSubClass.TestMethod(30, null, true),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 30, null, true }));
// 测试完整的调用与类型转换。
Type[] invalidCastExceptions =
{
typeof(ArgumentException), typeof(InvalidCastException), typeof(MissingMethodException)
};
Assert.AreEqual(TestSubClass.TestMethod(10),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10 }));
Assert.AreEqual(TestSubClass.TestMethod(10),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Explicit, null,
new object[] { (short)10 }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10L }), invalidCastExceptions);
Assert.AreEqual(TestSubClass.TestMethod(10),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Explicit, null,
new object[] { 10L }));
Assert.AreEqual(TestSubClass.TestMethod(10, 20),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10, (byte)20 }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10UL, 20L }), invalidCastExceptions);
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10, 20L }), invalidCastExceptions);
Assert.AreEqual(TestSubClass.TestMethod(10, 20),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Explicit, null,
new object[] { 10UL, 20L }));
// 测试命名参数。
Assert.AreEqual(TestSubClass.TestMethod(30, "str", true),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 30, "str", true }));
Assert.AreEqual(TestSubClass.TestMethod(value2: "str", value1: 30, value3: true),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { "str", 30, true }, null, null, new[] { "value2", "value1", "value3" }));
Assert.AreEqual(TestSubClass.TestMethod(30, "str", true),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { "str", 30, true }, null, null, new[] { "value2" }));
Assert.AreEqual(TestSubClass.TestMethod(value3: true, value2: "str", value1: 30),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { true, "str", 30 }, null, null, new[] { "value3", "value2", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod(30, "str", true),
type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { true, "str", 30 }, null, null, new[] { "value3", "value2" }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod", bindingFlags, PowerBinder.Default, null,
new object[] { 10 }, null, null, new[] { "values" }), typeof(MissingMethodException));
// 测试默认参数和 params 参数。
Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", true, 1, 2, 3 }));
Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", true }));
Assert.AreEqual(TestSubClass.TestMethod2(30, "str"),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str" }));
Assert.AreEqual(TestSubClass.TestMethod2(30),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30 }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[0]), typeof(MissingMethodException));
// 测试命名参数、默认参数和 params 参数。
Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value3: true, value4: new int[] { 1, 2, 3 }),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", true, 1, 2, 3 }, null, null,
new[] { "value1", "value2", "value3", "value4" }));
Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", true, 1, 2, 3 }, null, null,
new[] { "value1", "value2", "value3" }));
Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value3: true),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", true }, null, null,
new[] { "value1", "value2", "value3" }));
Assert.AreEqual(TestSubClass.TestMethod2(30, "str", true, 1, 2, 3),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", 1, true, 2, 3 }, null, null,
new[] { "value1", "value2", "value4" }));
Assert.AreEqual(TestSubClass.TestMethod2(value1: 30, value2: "str", value4: new[] { 1 }),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", new int[] { 1 } }, null, null,
new[] { "value1", "value2", "value4" }));
Assert.AreEqual(TestSubClass.TestMethod2(value4: new[] { 1 }, value3: true, value1: 30),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { new int[] { 1 }, true, 30 }, null, null,
new[] { "value4", "value3", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod2(value4: new[] { 1 }, value1: 30),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { new int[] { 1 }, 30 }, null, null,
new[] { "value4", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod2(value3: true, value1: 30),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { true, 30 }, null, null,
new string[] { "value3", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod2(value1: 30),
type.InvokeMember("TestMethod2", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30 }, null, null,
new[] { "value1" }));
// 测试泛型方法。
Assert.AreEqual(TestSubClass.TestMethod3(10, 20),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { 10, 20 }));
Assert.AreEqual(TestSubClass.TestMethod3(10, 20),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10, 20 }));
Assert.AreEqual(TestSubClass.TestMethod3((short)10, (short)20),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10, (short)20 }));
Assert.AreEqual(TestSubClass.TestMethod3(10, (long)20),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10, (long)20 }));
Assert.AreEqual(TestSubClass.TestMethod3(10, "str"),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { 10, "str" }));
Assert.AreEqual(TestSubClass.TestMethod3(10, "str"),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { (short)10, "str" }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { (long)10, "str" }), typeof(MissingMethodException));
Assert.AreEqual(TestSubClass.TestMethod3("text", "str"),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { "text", "str" }));
AssertExt.ThrowsException(() => type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { "str", 10 }), typeof(MissingMethodException));
Assert.AreEqual(TestSubClass.TestMethod3("text", "str", 10),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { "text", "str", 10 }));
Assert.AreEqual(TestSubClass.TestMethod3(10, 20, 30),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { 10, 20, 30 }));
Assert.AreEqual(TestSubClass.TestMethod3(10, 20, "str"),
type.InvokeMember("TestMethod3", bindingFlags, PowerBinder.Default, null,
new object[] { 10, 20, "str" }));
Assert.AreEqual("<System.Int32, System.String, System.Int32>(10, str, 20,30)",
type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.Default, null,
new object[] { 10, "str", 20, 30 }));
Assert.AreEqual("<System.Int32, System.String, System.Int64>(10, str, 20,30)",
type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.Default, null,
new object[] { 10, "str", 20L, 30 }));
Assert.AreEqual("<System.Int32, System.String, System.Int32>(10, test, 20,30)",
type.InvokeMember("TestMethod5", bindingOptFlags, PowerBinder.Default, null,
new object[] { 10, new int[] { 20, 30 }, "test" }, null, null,
new string[] { "value1", "value3", "value2" }));
// 测试选择方法。
BindingFlags bindingInsFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod;
BindingFlags bindingInsOptFlags = bindingInsFlags | BindingFlags.OptionalParamBinding;
TestSubClass subClass = new TestSubClass();
Assert.AreEqual(subClass.TestMethod4(10, 20),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, 20 }));
Assert.AreEqual(subClass.TestMethod4(true, "str"),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { true, "str" }));
Assert.AreEqual(subClass.TestMethod4(10, "str"),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str" }));
Assert.AreEqual(subClass.TestMethod4(10, "str"),
type.InvokeMember("TestMethod4", bindingInsOptFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str" }));
Assert.AreEqual(subClass.TestMethod4(10, "str", false),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str", false }));
Assert.AreEqual(subClass.TestMethod4(10, "str", 1),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str", 1 }));
Assert.AreEqual(subClass.TestMethod4(10, "str", new int[] { 1 }),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str", new int[] { 1 } }));
Assert.AreEqual(subClass.TestMethod4(10, "str", 1, 2),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Explicit, subClass,
new object[] { 10, "str", 1, 2 }));
Assert.AreEqual(subClass.TestMethod4(true, true),
type.InvokeMember("TestMethod4", bindingInsFlags, PowerBinder.Default, subClass,
new object[] { true, true }));
Assert.AreEqual(TestSubClass.TestMethod6(value2: 30, value1: "str"),
type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str" }, null, null,
new string[] { "value2", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod6(value2: (short)30, value1: "str"),
type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.Default, null,
new object[] { (short)30, "str" }, null, null,
new string[] { "value2", "value1" }));
Assert.AreEqual(TestSubClass.TestMethod6(value2: 30, value1: "str", value3: "str2"),
type.InvokeMember("TestMethod6", bindingOptFlags, PowerBinder.Default, null,
new object[] { 30, "str", "str2" }, null, null,
new string[] { "value2", "value1" }));
}
public void ReadSubClass()
{
TestClass testClass = (TestClass)NetReflector.Read(TestClass.GetXmlWithSubClass(DateTime.Now), table);
TestSubClass.AssertEquals(TestSubClass.Create(), (TestSubClass)testClass.InnerClass);
}
public void ShouldCreateAttachmentInSubCouchDocumentClass()
{
var db = client.GetDatabase(baseDatabase);
TestSubClass tsc = new TestSubClass {TESTVAL = "Hello"};
tsc = db.CreateDocument(tsc, new Result<TestSubClass>()).Wait();
var attachment = Encoding.UTF8.GetBytes("test");
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes("This is a text document")))
{
db.AddAttachment(tsc.Id, ms, "test_upload.txt");
}
tsc = db.GetDocument(tsc.Id, new Result<TestSubClass>()).Wait();
Assert.IsTrue(tsc.HasAttachment);
}
protected void TestField(MessageSerializedClassInfo classInfo, string propertyName, TestSubClass valueToUse, byte[] expectedArray)
{
MessageSerializedPropertyInfo propertyInfo = GetPropertyInfo(classInfo, propertyName);
TypeSerializerSerializableClass <TestSubClass> typeSerializer = new TypeSerializerSerializableClass <TestSubClass>(propertyInfo);
TestField(typeSerializer, propertyInfo, valueToUse, expectedArray);
}
public void Test_PutValue_DottedAspect_Success() {
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("This.This.VirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Assert
Assert.AreEqual(testValue, instance.VirtualTestProperty);
}
public void Test_PutValue_DottedAspect_CantModifyReadOnlyProperty() {
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
string testValue2 = "some test value2";
Munger munger = new Munger("This.This.ReadOnlyProperty");
instance.SetReadOnlyProperty(testValue);
Assert.AreEqual(testValue, instance.ReadOnlyProperty);
// Act
munger.PutValue(instance, testValue2);
// Assert
Assert.AreEqual(testValue, instance.ReadOnlyProperty);
}
public void Test_PutValue_NonVirtualProperty_CalledOnSubClass() {
// Arrange
TestSubClass instance = new TestSubClass();
string testValue = "some test value";
Munger munger = new Munger("NonVirtualTestProperty");
// Act
munger.PutValue(instance, testValue);
// Assert
Assert.AreEqual(testValue, instance.NonVirtualTestProperty);
Assert.IsTrue(instance.subClassPropertyModified);
}
