/// <summary>
/// Now try to understand this scenario, to call this method we need to pass these parameters.
/// Now there is no way to understand what these parameters are or how these parameters needs to be passed.
/// To find that we need to find Invoking Expression of "BusinessMethodDependency" and detects all it's parameter
/// initialize recursively.
/// To find dependencies we need to find the method "BusinessMethod" programmatically not hard coded fashion.
/// To test this method, we need to 2 setup methods
/// 1. Setup of Parameters from "BusinessMethod".
/// 2. Setup of inner properties (IntThrows, IntStaticThrows, PubliceByteProp, PublicStringProp), fields,
/// methods (ArgumentNullException, SomethingDynamicComplex, ThrowException,
/// BusinessLogicExampleOfSameplemethod, BusinessLogicExampleOfSamepleMethodString,
/// SampleMethod, SampleMethodString, ThrowException("Needs to be covered" + intX + y))
/// </summary>
/// <param name="somethingComplex"></param>
/// <param name="sample"></param>
/// <param name="classWithProperties"></param>
/// <param name="classWithMethods"></param>
/// <param name="required"></param>
/// <param name="prep"></param>
public void BusinessMethodDependency(dynamic somethingComplex,
dynamic sample,
ClassWithProperties classWithProperties,
ClassWithMethods classWithMethods,
IRequired required,
IRequiredPrep prep)
{
Utility.ArgumentNullException("Testing"); // this method needs to be Faked
somethingComplex.SomethingDynamicComplex();
var x = classWithProperties.PubliceByteProp;
var y = classWithProperties.PublicStringProp;
Utility.ThrowException(); // this method needs to be Faked
var classWithBusinessLogic = new ClassWithBusinessLogic(required);
classWithBusinessLogic.BusinessLogicExampleOfSameplemethod();
y = classWithBusinessLogic.BusinessLogicExampleOfSamepleMethodString() + x;
var classWithBusinessLogic2 = new ClassWithBusinessLogic2();
classWithBusinessLogic2.SampleMethodString();
var requiredConcrete = new Required();
requiredConcrete.SampleMethod(prep);
requiredConcrete.SampleMethodString(prep);
var intX = (int)sample + 5 + IntThrows + IntStaticThrows;
Utility.ThrowException("Needs to be covered" + intX + y); // this method needs to be Faked and covered
}
public void CallZeroParameterStaticMethod()
{
Expression <Action> lambda = () => ClassWithMethods.ZeroParameterStaticMethod();
var methodCallExpression = (MethodCallExpression)lambda.Body;
QUnit.AreEqual(methodCallExpression.Method.Name, "ZeroParameterStaticMethod");
}
/// <summary>
/// To test this method we need to find invocation expression of "BusinessMethod" in "BusinessMethodInitial2" and
/// "BusinessMethodInitial" and create two test method accordingly.
/// </summary>
/// <param name="x"></param>
/// <param name="somethingComplex"></param>
/// <param name="required"></param>
public void BusinessMethod(int x, dynamic somethingComplex, IRequired required)
{
var prep = new RequiredPrep();
var classWithProperties = new ClassWithProperties(required);
var classWithMethods = new ClassWithMethods(required);
BusinessMethodDependency(somethingComplex, x, classWithProperties, classWithMethods, required, prep);
}
public void CallZeroParameterInstanceMethod()
{
var instance = new ClassWithMethods();
Expression<Action> lambda = () => instance.ZeroParameterInstanceMethod();
var methodCallExpression = (MethodCallExpression)lambda.Body;
AssertEquals(methodCallExpression.Method.Name, "ZeroParameterInstanceMethod");
var target = (ConstantExpression)methodCallExpression.Object;
AssertEquals(target.Value, instance);
}
public void CallOneParameterStaticMethod()
{
Expression <Action> lambda = () => ClassWithMethods.OneParameterStaticMethod("foo");
var methodCallExpression = (MethodCallExpression)lambda.Body;
QUnit.AreEqual(methodCallExpression.Method.Name, "OneParameterStaticMethod");
var argument = (ConstantExpression)methodCallExpression.Arguments[0];
QUnit.AreEqual(argument.Value, "foo");
}
public void CallingPublicMethodFromProjectWithoutAccess()
{
// Arrange
var sut = new ClassWithMethods();
// Act
var greeting = sut.PublicMethod("human");
// Assert
Assert.AreEqual(greeting, "Hello human");
}
public void CallingInternalMethodFromProjectWithAccess()
{
// Arrange
var sut = new ClassWithMethods();
// Act
var greeting = sut.InternalMethod("human");
// Assert
Assert.AreEqual(greeting, "Howdy human");
}
public void CallZeroParameterInstanceMethod()
{
var instance = new ClassWithMethods();
Expression <Action> lambda = () => instance.ZeroParameterInstanceMethod();
var methodCallExpression = (MethodCallExpression)lambda.Body;
QUnit.AreEqual(methodCallExpression.Method.Name, "ZeroParameterInstanceMethod");
var target = (ConstantExpression)methodCallExpression.Object;
QUnit.AreEqual(target.Value, instance);
}
public void Should_create_MethodAccessor_for_method()
{
// Arrange
var method = new ClassWithMethods().Method("InvariantMethod");
// Act
IMethodAccessor accessor = sut.Create(method);
// Assert
accessor.Should().NotBeNull();
}
public void GetString_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
// Act
var result = classWithMethods.GetString();
// Assert
Assert.Fail();
}
public void GetFastMethodInvoker_ForGenericMethodTwoParameters()
{
var instance = new ClassWithMethods();
var invoker = _generator.GetFastMethodInvoker(
instance.GetType(),
"Count", new[] { typeof(int), typeof(string) },
new[] { typeof(IEnumerable <int>), typeof(string) }, BindingFlags.Public | BindingFlags.Instance);
var output = invoker(instance, new object[] { new[] { 3, 1, 2 }, "asdf" });
Assert.That(output, Is.EqualTo(7));
}
public void GetFastMethodInvoker_ForStaticGenericMethod()
{
var instance = new ClassWithMethods();
var invoker = _generator.GetFastMethodInvoker(
instance.GetType(),
"Count", new[] { typeof(int) },
new[] { typeof(IEnumerable <int>), typeof(int) }, BindingFlags.Public | BindingFlags.Static);
var output = invoker(instance, new object[] { new[] { 3, 1, 2 }, 1 });
Assert.That(output, Is.EqualTo(4));
}
public void GetFastMethodInvoker_ForGenericMethodTwoParameters()
{
var instance = new ClassWithMethods ();
var invoker = _generator.GetFastMethodInvoker (
instance.GetType (),
"Count", new[] { typeof (int), typeof(string) },
new[] { typeof (IEnumerable<int>), typeof (string) }, BindingFlags.Public | BindingFlags.Instance);
var output = invoker (instance, new object[] { new[] { 3, 1, 2 }, "asdf" });
Assert.That (output, Is.EqualTo (7));
}
public void AttributedMethod_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
string test = null;
// Act
classWithMethods.AttributedMethod(
test);
// Assert
Assert.Fail();
}
public void GetMethodDelegate_NestedProtectedInterface_ExplicitInterfaceMethod()
{
Type declaringType = typeof(IProtectedInterfaceWithMethods);
var methodInfo = declaringType.GetMethod("ExplicitInterfaceMethod", BindingFlags.Public | BindingFlags.Instance);
var @delegate = (Func <object, string, string>)DynamicMethodBasedMethodCallerFactory.CreateMethodCallerDelegate(
methodInfo, typeof(Func <object, string, string>));
var obj = new ClassWithMethods();
Assert.That(@delegate(obj, "TheValue"), Is.EqualTo("TheValue"));
Assert.That(obj.InstanceValue, Is.EqualTo("TheValue"));
}
public void GetMethodDelegate_NonPublicInstanceMethod()
{
Type declaringType = typeof(ClassWithMethods);
var methodInfo = declaringType.GetMethod("NonPublicInstanceMethod", BindingFlags.NonPublic | BindingFlags.Instance);
var @delegate = (Func <ClassWithMethods, string, string>)DynamicMethodBasedMethodCallerFactory.CreateMethodCallerDelegate(
methodInfo, typeof(Func <ClassWithMethods, string, string>));
var obj = new ClassWithMethods();
Assert.That(@delegate(obj, "TheValue"), Is.EqualTo("TheValue"));
Assert.That(obj.InstanceValue, Is.EqualTo("TheValue"));
}
public void GetIntMultipleSignatures_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
string bla = null;
// Act
var result = classWithMethods.GetIntMultipleSignatures(
bla);
// Assert
Assert.Fail();
}
public void MethodWithNamespaceQualifiedArgument_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
IInterface3 myInterface = null;
// Act
var result = classWithMethods.MethodWithNamespaceQualifiedArgument(
myInterface);
// Assert
Assert.Fail();
}
public void MethodWithNullableArgument_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
int?argument = null;
// Act
var result = classWithMethods.MethodWithNullableArgument(
argument);
// Assert
Assert.Fail();
}
public void DoEnum_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
Cucu cucuENum = default(global::UnitBoilerplate.Sandbox.Classes.Cases.Cucu);
// Act
classWithMethods.DoEnum(
cucuENum);
// Assert
Assert.Fail();
}
public void DoRef_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = this.CreateClassWithMethods();
ClassWithMethods refArg = null;
// Act
classWithMethods.DoRef(
ref refArg);
// Assert
Assert.Fail();
}
public void GetIntMultipleSignatures_StateUnderTest_ExpectedBehavior1()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
IInterface4 interface4 = null;
// Act
var result = classWithMethods.GetIntMultipleSignatures(
interface4);
// Assert
Assert.Fail();
}
public void DoRef_StateUnderTest_ExpectedBehavior()
{
// Arrange
var unitUnderTest = this.CreateClassWithMethods();
ClassWithMethods refArg = TODO;
// Act
unitUnderTest.DoRef(
ref refArg);
// Assert
Assert.Fail();
}
public void DoEnum_StateUnderTest_ExpectedBehavior()
{
// Arrange
var unitUnderTest = new ClassWithMethods(TODO, TODO);
Cucu cucuENum = TODO;
// Act
unitUnderTest.DoEnum(
cucuENum);
// Assert
Assert.Fail();
}
public void DoRef_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = this.CreateClassWithMethods();
ClassWithMethods refArg = null;
// Act
classWithMethods.DoRef(
ref refArg);
// Assert
Assert.True(false);
this.mockRepository.VerifyAll();
}
public async Task GetParamsClass2D_StateUnderTest_ExpectedBehavior()
{
// Arrange
var unitUnderTest = new ClassWithMethods(TODO, TODO);
ClassWithMethods[][] values = TODO;
// Act
var result = await unitUnderTest.GetParamsClass2D(
values);
// Assert
Assert.Fail();
}
public void DoRef_StateUnderTest_ExpectedBehavior()
{
// Arrange
var mocker = new AutoMoqer();
var classWithMethods = mocker.Create <ClassWithMethods>();
ClassWithMethods refArg = null;
// Act
classWithMethods.DoRef(
ref refArg);
// Assert
Assert.Fail();
}
public async Task GetWithClass4D_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
ClassWithMethods[][][][] values = null;
// Act
var result = await classWithMethods.GetWithClass4D(
values);
// Assert
Assert.Fail();
}
public void GetOut_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
bool fufu = false;
int bubu = 0;
// Act
var result = classWithMethods.GetOut(
fufu,
out bubu);
// Assert
Assert.Fail();
}
public async Task GetTaskNoAsync_StateUnderTest_ExpectedBehavior()
{
// Arrange
var unitUnderTest = new ClassWithMethods(TODO, TODO);
IInterface3 interface3 = TODO;
DateTime time = TODO;
// Act
await unitUnderTest.GetTaskNoAsync(
interface3,
time);
// Assert
Assert.Fail();
}
public async Task GetTaskNoAsync_StateUnderTest_ExpectedBehavior()
{
// Arrange
var classWithMethods = new ClassWithMethods(TODO, TODO);
IInterface3 interface3 = null;
DateTime time = default(global::System.DateTime);
// Act
await classWithMethods.GetTaskNoAsync(
interface3,
time);
// Assert
Assert.Fail();
}
public void EmitMethodBody_ForReferenceTypeInstance_InstanceTypesMatch()
{
Type declaringType = typeof(ClassWithMethods);
var methodInfo = declaringType.GetMethod("InstanceMethodWithReferenceTypeReturnValue", BindingFlags.Public | BindingFlags.Instance);
Type returnType = typeof(object);
Type[] parameterTypes = new[] { typeof(ClassWithMethods) };
var method = GetWrapperMethodFromEmitter(MethodInfo.GetCurrentMethod(), parameterTypes, returnType, methodInfo);
var obj = new ClassWithMethods {
InstanceReferenceTypeValue = new SimpleReferenceType()
};
Assert.That(BuildTypeAndInvokeMethod(method, obj), Is.SameAs(obj.InstanceReferenceTypeValue));
}
public void GetFastMethodInvoker_ForStaticGenericMethod()
{
var instance = new ClassWithMethods();
var invoker = _generator.GetFastMethodInvoker (
instance.GetType(),
"Count", new[] { typeof(int) },
new[] { typeof (IEnumerable<int>), typeof(int) }, BindingFlags.Public | BindingFlags.Static);
var output = invoker(instance, new object[] { new[] { 3, 1, 2 }, 1 });
Assert.That (output, Is.EqualTo (4));
}
public void Method(ClassWithMethods a) {}