public void ShimmedMethod_Generates_From_Empty_Static_Method_Call()
{
var shimmedMethod = new ShimmedMethod(typeof(StaticMethodsTestClass).GetMethod("EmptyMethod"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
try
{
var beforeDateTime = DateTime.Now;
PoseContext.Isolate(() => {
StaticMethodsTestClass.EmptyMethod();
}, new[] { shimmedMethod.Shim });
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void ShimmedMethod_Generates_From_Static_Call_With_Multi_Params_And_Returns_Value()
{
var shimmedMethod = new ShimmedMethod <int>(typeof(StaticMethodsTestClass).GetMethod("MethodWithParamsAndReturn"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
var beforeDateTime = DateTime.Now;
int value = -1;
PoseContext.Isolate(() => {
value = StaticMethodsTestClass.MethodWithParamsAndReturn(2, 4);
}, new[] { shimmedMethod.Shim });
Assert.AreEqual(0, value); // Shimmy will set to default for that value type
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
Assert.AreEqual(2, (int)callResult.Parameters[0]);
Assert.AreEqual(4, (int)callResult.Parameters[1]);
}
public void ShimmedMethod_Generates_From_Static_Call_With_Params_And_Returns_Reference_Type()
{
var shimmedMethod = new ShimmedMethod <List <int> >(typeof(StaticMethodsTestClass).GetMethod("MethodWithParamsAndReferenceTypeReturn"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
var beforeDateTime = DateTime.Now;
List <int> value = null;
PoseContext.Isolate(() => {
value = StaticMethodsTestClass.MethodWithParamsAndReferenceTypeReturn(2, 4);
}, new[] { shimmedMethod.Shim });
Assert.IsNotNull(value);
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
Assert.AreEqual(2, (int)callResult.Parameters[0]);
Assert.AreEqual(4, (int)callResult.Parameters[1]);
}
public void ShimmedMethod_Generates_From_Static_Call_With_Multi_Params_And_Returns_Reference_Type()
{
var shimmedMethod = new ShimmedMethod <List <int> >(typeof(StaticMethodsTestClass).GetMethod("MethodWithMultiReferenceTypeParamsAndReturn"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
var beforeDateTime = DateTime.Now;
List <int> value = null;
PoseContext.Isolate(() => {
value = StaticMethodsTestClass.MethodWithMultiReferenceTypeParamsAndReturn(new List <int> {
3, 2, 1
}, "bird", DateTime.Today);
}, new[] { shimmedMethod.Shim });
Assert.IsNotNull(value);
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
Assert.IsTrue(((List <int>)callResult.Parameters[0]).SequenceEqual(new List <int> {
3, 2, 1
}));
Assert.AreEqual("bird", (string)callResult.Parameters[1]);
Assert.AreEqual(DateTime.Today, (DateTime)callResult.Parameters[2]);
}
public void ShimmedMethod_Generates_From_Static_Call_Records_String_Parameters()
{
var shimmedMethod = new ShimmedMethod(typeof(StaticMethodsTestClass).GetMethod("MethodWithStringParam"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
var beforeDateTime = DateTime.Now;
PoseContext.Isolate(() => {
StaticMethodsTestClass.MethodWithStringParam("bird");
}, new[] { shimmedMethod.Shim });
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
var expectedParam = callResult.Parameters[0];
Assert.AreEqual("bird", (string)expectedParam);
}
public void PoseWrapper_SetReturn_Changes_Value_Of_Correct_Shim_On_Function_Call()
{
var a = new TestClass();
var wrapper = new PoseWrapper <bool>((Func <bool>)a.CallTwoDifferentMethods, null, WrapperOptions.None);
var methodInfo1 = typeof(StaticMethodsTestClass).GetMethod("MethodWithParamAndReturn");
var methodInfo2 = typeof(StaticMethodsTestClass).GetMethod("MethodWithParamsAndReturn");
wrapper.SetReturn(() => StaticMethodsTestClass.MethodWithParamAndReturn(Pose.Is.A <int>()), 3);
wrapper.SetReturn(() => StaticMethodsTestClass.MethodWithParamsAndReturn(Pose.Is.A <int>(), Pose.Is.A <int>()), 7);
var preCallDateTime = DateTime.Now;
var result = wrapper.Execute();
Assert.IsTrue(result);
Assert.AreEqual(2, wrapper.LastExecutionResults.Count);
var resultsMethodWithParamAndReturn = wrapper.LastExecutionResults.First(ler => ler.Key.Equals(methodInfo1)).Value;
var resultsMethodWithParamsAndReturn = wrapper.LastExecutionResults.First(ler => ler.Key.Equals(methodInfo2)).Value;
Assert.AreEqual(1, resultsMethodWithParamAndReturn.Count);
Assert.AreEqual(1, resultsMethodWithParamsAndReturn.Count);
var resultsMethodWithParamAndReturnData = resultsMethodWithParamAndReturn[0];
var resultsMethodWithParamsAndReturnData = resultsMethodWithParamsAndReturn[0];
Assert.IsTrue(resultsMethodWithParamAndReturnData.CalledAt > preCallDateTime);
Assert.IsTrue(resultsMethodWithParamsAndReturnData.CalledAt > resultsMethodWithParamAndReturnData.CalledAt);
Assert.AreEqual(5, (int)resultsMethodWithParamAndReturnData.Parameters[0]);
Assert.AreEqual(7, (int)resultsMethodWithParamsAndReturnData.Parameters[0]);
Assert.AreEqual(1, (int)resultsMethodWithParamsAndReturnData.Parameters[1]);
}
public bool CallTwoDifferentMethods()
{
var result1 = StaticMethodsTestClass.MethodWithParamAndReturn(5);
var result2 = StaticMethodsTestClass.MethodWithParamsAndReturn(7, 1);
return(result1 < result2);
}
public void ShimmedMethod_Generates_From_Static_Call_Records_Multi_Parameters()
{
var shimmedMethod = new ShimmedMethod(typeof(StaticMethodsTestClass).GetMethod("MethodWithMultiParams"));
Assert.IsNotNull(shimmedMethod);
Assert.IsNotNull(shimmedMethod.Method);
Assert.IsNotNull(shimmedMethod.Shim);
var beforeDateTime = DateTime.Now;
PoseContext.Isolate(() => {
StaticMethodsTestClass.MethodWithMultiParams(5, 6, "bird", new List <bool> {
true, false, true
});
}, new[] { shimmedMethod.Shim });
Assert.AreEqual(1, shimmedMethod.CallResults.Count);
var callResult = shimmedMethod.CallResults.First();
Assert.IsNotNull(callResult.Parameters);
var afterDateTime = DateTime.Now;
Assert.IsNotNull(callResult.CalledAt);
Assert.IsTrue(beforeDateTime < callResult.CalledAt && callResult.CalledAt < afterDateTime);
Assert.AreEqual(5, (int)callResult.Parameters[0]);
Assert.AreEqual(6, (int)callResult.Parameters[1]);
Assert.AreEqual("bird", (string)callResult.Parameters[2]);
Assert.IsTrue(new List <bool> {
true, false, true
}.SequenceEqual((List <bool>)callResult.Parameters[3]));
}
public int CallSameMethodMultipleTimes()
{
var result = 0;
result += StaticMethodsTestClass.MethodWithParamAndReturn(10);
result += StaticMethodsTestClass.MethodWithParamAndReturn(9);
result += StaticMethodsTestClass.MethodWithParamAndReturn(8);
result += StaticMethodsTestClass.MethodWithParamAndReturn(7);
result += StaticMethodsTestClass.MethodWithParamAndReturn(6);
return(result);
}
public void PoseWrapper_Returns_Results_Per_Method_By_Expression()
{
var a = new TestClass();
var wrapper = new PoseWrapper <bool>((Func <bool>)a.CallTwoDifferentMethods, null, WrapperOptions.None);
var methodInfo = typeof(StaticMethodsTestClass).GetMethod("MethodWithParamsAndReturn");
var result = wrapper.Execute();
var callResults = wrapper.ResultsFor(() => StaticMethodsTestClass.MethodWithParamsAndReturn(Pose.Is.A <int>(), Pose.Is.A <int>()));
Assert.IsNotNull(callResults);
Assert.AreEqual(1, callResults.Count);
Assert.IsTrue(callResults.SequenceEqual(wrapper.LastExecutionResults.FirstOrDefault(m => m.Key == methodInfo).Value));
}
public void MethodWithObjectParam(List <bool> l)
{
StaticMethodsTestClass.MethodWithObjectParam(l);
}
public void CallTheSameMethodTwice()
{
StaticMethodsTestClass.EmptyMethod();
StaticMethodsTestClass.EmptyMethod();
}
public void MethodWithMultiParams(int a, int b, string c, List <bool> d)
{
StaticMethodsTestClass.MethodWithMultiParams(a, b, c, d);
}
private int APrivateMethodWithCalls()
{
return(StaticMethodsTestClass.MethodWithParamAndReturn(5));
}
public int MethodWithParamsAndReturn(int param1, int param2)
{
return(StaticMethodsTestClass.MethodWithParamsAndReturn(param1, param2));
}
public int MethodWithReturn()
{
return(StaticMethodsTestClass.MethodWithReturn());
}
public void MethodWithStringParam(string b)
{
StaticMethodsTestClass.MethodWithStringParam(b);
}
public void VoidMethod()
{
var result = StaticMethodsTestClass.MethodWithParamAndReturn(2);
}
public List <int> MethodWithParamsAndReferenceTypeReturn(int param1, int param2)
{
return(StaticMethodsTestClass.MethodWithParamsAndReferenceTypeReturn(param1, param2));
}
public List <int> MethodWithMultiReferenceTypeParamsAndReturn(List <int> a, string b, DateTime c)
{
return(StaticMethodsTestClass.MethodWithMultiReferenceTypeParamsAndReturn(a, b, c));
}
public List <int> MethodWithReferenceTypeParamsAndReturn(List <int> args)
{
return(StaticMethodsTestClass.MethodWithReferenceTypeParamsAndReturn(args));
}
public void MethodWithValueTypeParam(int a)
{
var result = StaticMethodsTestClass.MethodWithParamAndReturn(a);
}
public void EmptyMethod()
{
StaticMethodsTestClass.EmptyMethod();
}
public int MethodWithReturn()
{
return(StaticMethodsTestClass.MethodWithParamAndReturn(2));
}
public void MethodWithValueTypeParam(int a)
{
StaticMethodsTestClass.MethodWithValueTypeParam(a);
}
public int MethodWithParamAndReturn(int a)
{
return(StaticMethodsTestClass.MethodWithParamAndReturn(a));
}
public static int MethodWithParamAndReturn(int param1)
{
return StaticMethodsTestClass.MethodWithParamAndReturn(param1);
}