public TestReturn(ReturnTestDelegate test)
{
if (test == null)
{
throw new ArgumentNullException(nameof(test));
}
_test = test;
}
/// <summary>
/// Test helper for invoke operation return type testing
/// </summary>
/// <typeparam name="T">expected return type</typeparam>
/// <param name="provider">an instance to the test scenarios domain service</param>
/// <param name="testMethod">the invoke operation to be tested</param>
/// <param name="inputValue">input value to the test method. This should
/// be of type T</param>
private void VerifyOnlineMethodReturn <T>(TestProvider_Scenarios provider, ReturnTestDelegate <T> testMethod, T inputValue)
{
InvokeOperation invoke = null;
EnqueueCallback(delegate
{
Type[] genericArguments = typeof(T).GetGenericArguments();
string genericType = (genericArguments != null && genericArguments.Length > 0) ? ("<" + genericArguments[0].Name + ">") : "";
Console.WriteLine("Verify invoke operation using return type '{0}{1}'...", typeof(T).Name, genericType);
// call invoke operation with the input value
invoke = testMethod(inputValue, TestHelperMethods.DefaultOperationAction, null);
});
// wait for invoke operation to return.
EnqueueConditional(() => invoke.IsComplete);
EnqueueCallback(delegate
{
// verify invocation completed succesfully
Assert.IsNull(invoke.Error, string.Format("InvokeEventArgs.Error should be null.\r\nMessage: {0}\r\nStack Trace:\r\n{1}", invoke.Error != null ? invoke.Error.Message : string.Empty, invoke.Error != null ? invoke.Error.StackTrace : string.Empty));
Assert.IsFalse(invoke.ValidationErrors.Any());
// verify the inputValue is correctly round-tripped back as returnValue
if (inputValue == null)
{
Assert.IsNull(invoke.Value);
}
else
{
if (TypeUtility.FindIEnumerable(typeof(T)) == null)
{
Assert.AreEqual(inputValue.GetType(), invoke.Value.GetType());
}
else
{
Assert.AreEqual(TypeUtility.GetElementType(inputValue.GetType()), TypeUtility.GetElementType(invoke.Value.GetType()));
}
if (TypeUtility.GetNonNullableType(typeof(T)) == typeof(DateTime))
{
DateTime returnedDate = (DateTime)invoke.Value;
Assert.AreEqual(((DateTime)(object)inputValue).Kind, returnedDate.Kind);
Assert.AreEqual(inputValue, returnedDate);
}
else if (TypeUtility.GetNonNullableType(typeof(T)) == typeof(DateTimeOffset))
{
DateTimeOffset returnedDate = (DateTimeOffset)invoke.Value;
Assert.AreEqual(((DateTimeOffset)(object)inputValue).Offset.Ticks, returnedDate.Offset.Ticks);
Assert.AreEqual(inputValue, returnedDate);
}
else if (typeof(T) == typeof(byte[]))
{
// if T is byte[], we verify count matches as well as the elements matching
Assert.AreEqual(typeof(byte[]), invoke.Value.GetType());
byte[] returnedArray = invoke.Value as byte[];
byte[] inputArray = inputValue as byte[];
Assert.AreEqual(inputArray.Length, returnedArray.Length);
for (int i = 0; i < returnedArray.Length; i++)
{
Assert.AreEqual(inputArray[i], returnedArray[i], string.Format("array elements {0} should be equal", i));
}
}
else if (TypeUtility.IsPredefinedListType(typeof(T)))
{
IEnumerable <object> inputEnumerable = ((IEnumerable)inputValue).Cast <object>();
IEnumerable <object> resultEnumerable = ((IEnumerable)invoke.Value).Cast <object>();
Assert.IsTrue(inputEnumerable.SequenceEqual(resultEnumerable));
}
else
{
Assert.AreEqual(inputValue, invoke.Value);
}
}
Console.WriteLine("...Completed");
});
}
public static TestReturn Is(ReturnTestDelegate test)
{
return(new TestReturn(test));
}
