public void Parse_WhenOnlyMemberIsPassed_ThrowsException()
		{
			var parser = new WhereParser();
			var expression = Reflect<MyClass>.LambdaFrom(m => m.String1);

			var ex = Assert.Throws<SisoDbException>(
				() => parser.Parse(expression));

			Assert.AreEqual(ExceptionMessages.WhereExpressionParser_NoMemberExpressions, ex.Message);
		}
		public void Parse_WhenUnsupportedMethodInvocation_NotSupportedException()
		{
			var parser = new WhereParser();
			var expression = Reflect<MyClass>.LambdaFrom(m => m.String1 == Convert.ToString(m.Int1));

			var ex = Assert.Throws<NotSupportedException>(
				() => parser.Parse(expression));

			Assert.AreEqual(
				ExceptionMessages.LambdaParser_UnsupportedMethodCall.Inject("ToString(m.Int1)"),
				ex.Message);
		}
        public void Parse_WhenStartsWith_ReturnsCorrectNodes()
        {
            var expression = Reflect<MyClass>.LambdaFrom(m => m.String1.StartsWith("Foo"));

            var parser = new WhereParser();
            var parsedLambda = parser.Parse(expression);

            var listOfNodes = parsedLambda.Nodes.ToList();
            var memberNode = (MemberNode)listOfNodes[0];
            var operatorNode = (OperatorNode)listOfNodes[1];
            var operandNode = (ValueNode)listOfNodes[2];
            Assert.AreEqual("String1", memberNode.Path);
            Assert.AreEqual("like", operatorNode.Operator.ToString());
            Assert.AreEqual("Foo%", operandNode.Value);
        }
		public void Parse_WhenStartsWith_AgainstValueOfProperty_ReturnsCorrectNodes()
		{
			var q = new StartsWithQueryObject{Value = "Foo"};
			var expression = q.CreateExpression();

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			var memberNode = (MemberNode)listOfNodes[0];
			var operatorNode = (OperatorNode)listOfNodes[1];
			var operandNode = (ValueNode)listOfNodes[2];
			Assert.AreEqual("String1", memberNode.Path);
			Assert.AreEqual("like", operatorNode.Operator.ToString());
			Assert.AreEqual("Foo%", operandNode.Value);
		}
		public void Parse_WhenBoolWithoutComparisionOperator_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.Bool1);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(3, listOfNodes.Count);

			var memberNode = (MemberNode)listOfNodes[0];
			var equalNode = (OperatorNode) listOfNodes[1];
			var valueNode = (ValueNode) listOfNodes[2];

			Assert.AreEqual("Bool1", memberNode.Path);
			Assert.AreEqual(typeof(bool), memberNode.MemberType);
			Assert.AreEqual("=", equalNode.ToString());
			Assert.AreEqual(true, valueNode.Value);
		}
		public ExpressionParsers(IDataTypeConverter dataTypeConverter)
		{
			IncludeParser = new IncludeParser(dataTypeConverter);
			WhereParser = new WhereParser(dataTypeConverter);
			OrderByParser = new OrderByParser(dataTypeConverter);
		}
		public void Parse_WhenQxEndsWithOnToStringOfNullableValue_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.NullableInt.HasValue && m.NullableInt.Value.ToString().QxEndsWith("42"));

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(7, listOfNodes.Count);

			var memberNode1 = (NullableMemberNode)listOfNodes[0];
			var isNotNode1 = (OperatorNode)listOfNodes[1];
			var nullNode1 = (NullNode)listOfNodes[2];
			var andNode = (OperatorNode)listOfNodes[3];
			var memberNode2 = (EndsWithMemberNode)listOfNodes[4];
			var likeNode = (OperatorNode)listOfNodes[5];
			var valueNode = (ValueNode)listOfNodes[6];

			Assert.AreEqual("NullableInt", memberNode1.Path);
			Assert.AreEqual(typeof(int), memberNode1.MemberType);
			Assert.AreEqual("is not", isNotNode1.Operator.ToString());
			Assert.AreEqual("null", nullNode1.ToString());
			Assert.AreEqual("and", andNode.ToString());
			Assert.AreEqual("NullableInt", memberNode2.Path);
			Assert.AreEqual(typeof(int), memberNode2.MemberType);
			Assert.AreEqual("like", likeNode.Operator.ToString());
			Assert.AreEqual("%42", valueNode.Value);
		}
		public void Parse_WhenNullableHasValueIsComparedAgainstNegatedImplicitValueOfTrue_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => !m.NullableInt1.HasValue);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(4, listOfNodes.Count);

			var negationNode = (OperatorNode)listOfNodes[0];
			var memberNode = (NullableMemberNode)listOfNodes[1];
			var operatorNode = (OperatorNode)listOfNodes[2];
			var nullNode = (NullNode)listOfNodes[3];

			Assert.AreEqual("not", negationNode.Operator.ToString());
			Assert.AreEqual("NullableInt1", memberNode.Path);
			Assert.AreEqual(typeof(int), memberNode.MemberType);
			Assert.AreEqual("is not", operatorNode.Operator.ToString());
			Assert.AreEqual("null", nullNode.ToString());
		}
		public void Parse_WhenNullableIsNotNull_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.NullableInt1 != null);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(3, listOfNodes.Count);

			var memberNode = (NullableMemberNode)listOfNodes[0];
			var operatorNode = (OperatorNode)listOfNodes[1];
			var nullNode = (NullNode)listOfNodes[2];

			Assert.AreEqual("NullableInt1", memberNode.Path);
			Assert.AreEqual(typeof(int), memberNode.MemberType);
			Assert.AreEqual("is not", operatorNode.Operator.ToString());
			Assert.AreEqual("null", nullNode.ToString());
		}
		public void Parse_WhenNullableValueIsComparedAgainstValue_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.NullableInt1.Value == 1);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(3, listOfNodes.Count);

			var memberNode = (NullableMemberNode)listOfNodes[0];
			var operatorNode = (OperatorNode)listOfNodes[1];
			var operandNode = (ValueNode)listOfNodes[2];

			Assert.AreEqual("NullableInt1", memberNode.Path);
			Assert.AreEqual(typeof(int), memberNode.MemberType);
			Assert.AreEqual("=", operatorNode.Operator.ToString());
			Assert.AreEqual(1, operandNode.Value);
		}
		public void Parse_WhenCombiningNullableHasValueAndValueInExpression_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.NullableInt1.HasValue && m.NullableInt1 != null);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(9, listOfNodes.Count);

			var startGroupNode = (StartGroupNode) listOfNodes[0];
			var memberNode1 = (NullableMemberNode)listOfNodes[1];
			var isNotNode1 = (OperatorNode)listOfNodes[2];
			var nullNode1 = (NullNode)listOfNodes[3];
			var andNode = (OperatorNode) listOfNodes[4];
			var memberNode2 = (NullableMemberNode)listOfNodes[5];
			var isNotNode2 = (OperatorNode)listOfNodes[6];
			var nullNode2 = (NullNode)listOfNodes[7];
			var endGroupNode = (EndGroupNode) listOfNodes[8];

			Assert.AreEqual("NullableInt1", memberNode1.Path);
			Assert.AreEqual(typeof(int), memberNode1.MemberType);
			Assert.AreEqual("is not", isNotNode1.Operator.ToString());
			Assert.AreEqual("null", nullNode1.ToString());
			Assert.AreEqual("and", andNode.ToString());
			Assert.AreEqual("NullableInt1", memberNode2.Path);
			Assert.AreEqual(typeof(int), memberNode2.MemberType);
			Assert.AreEqual("is not", isNotNode2.Operator.ToString());
			Assert.AreEqual("null", nullNode2.ToString());
		}
		public void Parse_WhenBoolWithoutComparisionOperatorAndWithNullable_ReturnsCorrectNodes()
		{
			var expression = Reflect<MyClass>.LambdaFrom(m => m.Bool1 || m.NullableInt1.HasValue);

			var parser = new WhereParser();
			var parsedLambda = parser.Parse(expression);

			var listOfNodes = parsedLambda.Nodes.ToList();
			Assert.AreEqual(7, listOfNodes.Count);

			var memberNode1 = (MemberNode)listOfNodes[0];
			var equalNode = (OperatorNode)listOfNodes[1];
			var valueNode = (ValueNode)listOfNodes[2];
			var orNode = (OperatorNode)listOfNodes[3];
			var memberNode2 = (NullableMemberNode)listOfNodes[4];
			var isNotNode2 = (OperatorNode)listOfNodes[5];
			var nullNode2 = (NullNode)listOfNodes[6];
			
			Assert.AreEqual("Bool1", memberNode1.Path);
			Assert.AreEqual(typeof(bool), memberNode1.MemberType);
			Assert.AreEqual("=", equalNode.Operator.ToString());
			Assert.AreEqual(true, valueNode.Value);
			Assert.AreEqual("or", orNode.ToString());
			Assert.AreEqual("NullableInt1", memberNode2.Path);
			Assert.AreEqual(typeof(int), memberNode2.MemberType);
			Assert.AreEqual("is not", isNotNode2.Operator.ToString());
			Assert.AreEqual("null", nullNode2.ToString());
		}
 public ExpressionParsers(IDataTypeConverter dataTypeConverter)
 {
     WhereParser   = new WhereParser(dataTypeConverter);
     OrderByParser = new OrderByParser(dataTypeConverter);
 }