public static T Evaluate <T>(this object instance, string method, string expression)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var expr = Expression <T> .Create(method,
ExpressionTest <T> .CreateWithExpression(expression));
expr.ExpressionTest.Target.Type = instance.GetType();
expr.ExpressionTest.TargetInstance = instance;
throw new InvalidOperationException($"[{expression}] is Invalid!");
}
public void TestMethod_GetMessage_WrongFieldName()
{
Assert.Throws <FieldNotFoundException>(
() =>
ExpressionTest <Dummy>
.CreateMethodExpression(nameof(Dummy.GetMessage), typeof(Dummy).GetFieldValue(WrongFieldName))
.TestAndVerify());
}
public void TestMethod_CharAt1()
{
var classInfo = ClassInfo <Dummy> .Create(new Dictionary <string, dynamic>
{
{ MessageField, "012345789" }
});
ExpressionTest <Dummy> .CreateMethodExpression(nameof(Dummy.CharAt1), classInfo, "_message[1] == '1'").TestAndVerify();
}
public void TestMethod_GetMessage_WithUserDefinedFields()
{
var classInfo = ClassInfo <Dummy> .Create(new Dictionary <string, object>
{
{ MessageField, "CustomMessage" }
});
ExpressionTest <Dummy> .CreateTest(MessageField, classInfo, "CustomMessage").TestAndVerify();
}
internal static object[] GetParentExpressionValue <T>(this ExpressionTest <T> expressionTest)
{
if (expressionTest.Expressions == null)
{
return(new[] { expressionTest.TargetInstance });
}
var parentExpressions = new object[expressionTest.Expressions.Length];
for (var i = 0; i < expressionTest.Expressions.Length; i++)
{
var expression = expressionTest.Expressions[i];
expression = Regex.Replace(expression, "\\[", ".[");
expression = expression.Replace("this.", "");
var members = expression.Split('.');
for (var index = 0; index < members.Length; index++)
{
var member = Regex.Replace(members[index], "\\(\\)", "");
if (parentExpressions[i] == null)
{
parentExpressions[i] = expressionTest.TargetInstance;
}
var parentExpressionClass = parentExpressions[i] == null
? expressionTest.Target.Type
: parentExpressions[i].GetType();
var fieldInfo = parentExpressionClass.FindFieldByName(member);
var propertyGetter = TypeUtility.FindPropertyByName(parentExpressionClass, member);
var method = parentExpressionClass.FindMethodByName(member);
if (fieldInfo == null && propertyGetter == null && method == null)
{
if (parentExpressionClass.IsACollection())
{
try
{
parentExpressions[i] = ExpressionEvaluator.GetValue(parentExpressions[i], members[index]);
}
catch (Exception)
{
parentExpressions[i] = TypeUtility.GetFirstObjectFromCollection(parentExpressions[i]);
index--;
}
}
else
{
break;
}
}
parentExpressions[i] = SetParentExpressionValue(fieldInfo, propertyGetter, method,
parentExpressions[i]);
}
}
return(parentExpressions);
}
public void TestMethod_AddLongItems()
{
ExpressionTest <Dummy> .CreateTest(nameof(Dummy.AddLongItems), "_longList.Count", 50).TestAndVerify();
TypeUtility.InitializeInstanceCollectionFields = false;
ExpressionTest <Dummy> .CreateTest(nameof(Dummy.AddLongItems), "_longList.Count", 25).TestAndVerify();
TypeUtility.InitializeInstanceCollectionFields = true;
}
public void TestMethod_AddItem()
{
ExpressionTest <Dummy> .CreateTest(nameof(Dummy.AddItem), "_classList.Count", 26).TestAndVerify();
TypeUtility.InitializeInstanceCollectionFields = false;
ExpressionTest <Dummy> .CreateTest(nameof(Dummy.AddItem), "_classList.Count", 1).TestAndVerify();
TypeUtility.InitializeInstanceCollectionFields = true;
}
public void TestMethods_UsingExpressions()
{
var methods = new List <Expression <Dummy> >
{
Expression <Dummy> .Create(nameof(GetType), ExpressionTest <Dummy> .CreateTest("Name", "Dummy")),
Expression <Dummy> .Create(nameof(GetType), ExpressionTest <Dummy> .CreateTest("GetFields[0].Name", "DummyClassType"))
};
_tester.TestAndVerifyMethods(methods);
}
public void TestMethod_ReturnMessage()
{
// Arrange
var methods = new List <Expression <Dummy> >
{
Expression <Dummy>
.Create(nameof(Dummy.ReturnMessage), new object[] { "ExpressionTest-1", "ExpressionTest-2" },
ExpressionTest <Dummy> .CreateTest("ExpressionTest-1 ExpressionTest-2"))
};
// Assert
_tester.TestAndVerifyMethods(methods);
}
public void TestMethod_GetMessage()
{
// Solution 1
ExpressionTest <Dummy>
.CreateMethodExpression(nameof(Dummy.GetMessage), typeof(Dummy).GetFieldValue(MessageField))
.TestAndVerify();
// Solution 2
// Arrange
var dummy = typeof(Dummy)
.CreateInstance() as Dummy;
// Act
var message = dummy?.GetMessage();
// Assert
message.ShouldBe(dummy.Evaluate <string>(MessageField));
}
public void TestMethod_GetSquareRoot()
{
const double expectedOutput = 25.9422435421457;
// Solution 1
ExpressionTest <Dummy> .CreateTest(SquareRootMethod, expectedOutput).TestAndVerify();
// Solution 2
// Arrange
var dummy = new Dummy();
// Act
var result = dummy.Evaluate <double>(SquareRootMethod);
// Assert
result.ShouldBe(expectedOutput);
}
public void TestMethod_GetException()
{
const string outputExpression = "_exception";
// Solution 1
ExpressionTest <Dummy> .CreateWithOutputExpression(nameof(Dummy.GetException), outputExpression).TestAndVerify();
// Solution 2
// Arrange
var dummy = new Dummy();
// Act
var exception = dummy.GetException();
// Assert
exception.ShouldBe(dummy.Evaluate <Exception>(outputExpression));
}
//Let's not get too fancy and over engineer this. Just run through some prebaked test cases and compare them to expected results
//Rolling my own unit testing framework will just distract me.
//Basic test driver is a good exercise. Not full fledged by any measure.
//Alright, we'll make test objects that run themselves and passback result objs.
public static void Main(string[] args)
{
Console.WriteLine("Expression Test");
TestCase test = new ExpressionTest();
List <TestResult> res = test.run();
bool testResult = true;
foreach (TestResult result in res)
{
Console.WriteLine(result.printResult());
if (!result.getPass())
{
testResult = false;
}
}
Console.WriteLine(testResult);
Console.WriteLine();
Console.WriteLine("Parser Test");
test = new ParserTest();
res = test.run();
foreach (TestResult result in res)
{
Console.WriteLine(result.printResult());
if (!result.getPass())
{
testResult = false;
}
}
Console.WriteLine(testResult);
Console.WriteLine();
Console.WriteLine("Interface Test");
test = new InterfaceTest();
res = test.run();
foreach (TestResult result in res)
{
Console.WriteLine(result.printResult());
if (!result.getPass())
{
testResult = false;
}
}
Console.WriteLine(testResult);
Console.WriteLine();
}
public void TestMethod_SetMessage()
{
var testMessage = "test-message";
var expression = MessageField;
// Solution 1
ExpressionTest <Dummy> .CreateWithOutputExpression(nameof(Dummy.SetMessage), expression, "@p0 + @p0").TestAndVerify();
// Solution 2
// Arrange
var dummy = new Dummy();
// Act
dummy.SetMessage(testMessage);
// Assert
dummy.Evaluate <string>(expression)
.ShouldBe(testMessage + testMessage);
}
public static T Evaluate <T>(this object instance, string expression)
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var expressionTest = ExpressionTest <T> .CreateWithExpression(expression);
expressionTest.TargetInstance = instance;
expressionTest.Target.Type = instance.GetType();
expressionTest.Test();
return((T)expressionTest.ActualOutputs.First());
}
internal static void SetTestActualOutput <T>(this ExpressionTest <T> expressionTest, object[] expressionValues)
{
for (var i = 0; i < expressionValues.Length; i++)
{
try
{
if (
SerializeUtility.Serialize(expressionTest.ExpectedOutputs[i])
.Equals(SerializeUtility.Serialize(Enum.Enum.Instance.NotNull)) &&
expressionValues[i] != null)
{
expressionTest.ActualOutputs[i] = Enum.Enum.Instance.NotNull;
}
else if (
SerializeUtility.Serialize(expressionTest.ExpectedOutputs[i])
.Equals(SerializeUtility.Serialize(Enum.Enum.Instance.Null)) && expressionValues[i] == null)
{
expressionTest.ActualOutputs[i] = Enum.Enum.Instance.Null;
}
else if (expressionValues[i] != null && expressionValues[i] is Type)
{
expressionTest.ActualOutputs[i] = ((Type)expressionValues[i]).FullName;
}
else
{
expressionTest.ActualOutputs[i] = expressionValues[i];
}
}
catch (Exception e)
{
if (e.InnerException != null)
{
expressionTest.ActualOutputs[i] = e.InnerException.GetType().FullName;
}
else
{
expressionTest.ActualOutputs[i] = e.GetType().FullName;
}
}
}
}
public void TestMethod_ReturnMessage_WithWrongExpectedOutput()
{
Assert.Throws <NoMatchedException>(
() => ExpressionTest <Dummy> .CreateMethodExpression(nameof(Dummy.ReturnMessage), "Wrong Expected Output").TestAndVerify());
}
public void TestMethod_NotEqual()
{
ExpressionTest <Dummy> .CreateWithOutputExpression(nameof(Dummy.NotEqual), "_number1 != _number2").TestAndVerify();
}
public void TestMethod_ReturnCurrentInstance()
{
ExpressionTest <Dummy> .CreateMethodOutputExpression(nameof(Dummy.ReturnCurrentInstance), "this").TestAndVerify();
}
public void TestMethod_Equal()
{
ExpressionTest <Dummy> .CreateMethodOutputExpression(nameof(Dummy.Equals), "_number1 == _number2").TestAndVerify();
}
public void TestMethod_MethodWithListAsParameter()
{
ExpressionTest <Dummy>
.CreateMethodExpression(nameof(Dummy.MethodWithListAsParameter), "Test Output-0556 Test Output-1556").TestAndVerify();
}
public void ThrowSystemException()
{
ExpressionTest <Dummy> .CreateMethodExpression(nameof(Dummy.ThrowSystemException), typeof(System.SystemException).Name).TestAndVerify();
}
public void TestMethod_GetDummyTestStringArray()
{
ExpressionTest <Dummy> .CreateMethodOutputExpression(nameof(Dummy.GetDummyTestStringArray), "_stringArray").TestAndVerify();
}
public void TestMethod_ReturnCharacter()
{
ExpressionTest <Dummy> .CreateTest(nameof(Dummy.ReturnCharacter), 'a').TestAndVerify();
}
public void TestMethod_Message_ClassWithNoConstructor()
{
ExpressionTest <DummyWithNoConstructor> .CreateTest(nameof(DummyWithNoConstructor.Message), "Test_Message").TestAndVerify();
}
public void TestMethod_WithNullParameters()
{
Expression <Dummy> .CreateWithNullParameters("ReturnMessage2", ExpressionTest <Dummy> .CreateTest(null)).TestAndVerify();
}
public void TestMethod_ReturnInteger()
{
ExpressionTest <Dummy> .CreateMethodOutputExpression(nameof(Dummy.ReturnInteger), "5").TestAndVerify();
}
public void TestMethod_ToString()
{
ExpressionTest <Dummy> .CreateWithOutputExpression(nameof(Dummy.ToString), "'_message=' + _message + 'message2=' + _message2 + 'number1=' + _number1")
.TestAndVerify();
}
public void TestMethod_WithUserDefinedParameters()
{
Expression <Dummy> .Create("ReturnMessage2", new object[] { "Test" }, ExpressionTest <Dummy> .CreateTest("Test")).TestAndVerify();
}
public void TestMethod_WrongMethod()
{
Assert.Throws <MethodNotFoundException>(
() => ExpressionTest <Dummy> .CreateMethodExpression("WrongMethod", null).TestAndVerify());
}
