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)); }