Beispiel #1
0
		public bool Equals(TestType other)
		{
			if (ReferenceEquals(null, other)) return false;
			if (ReferenceEquals(this, other)) return true;
			return other.IntColumn == IntColumn && other.BoolColumn.Equals(BoolColumn) &&
			       Equals(other.StringColumn, StringColumn);
		}
		public void Can_select_smaller_than_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 1,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn < 1);

			Assert.IsNotNull(actual);
			Assert.AreEqual(0, actual.Count);
		}
		public void Can_select_not_equals_constant_int_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn != 3);

			Assert.IsNotNull(actual);
			Assert.AreEqual(10, actual.Count);
			CollectionAssert.DoesNotContain(actual, expected);
		}
		public void Can_select_equals_int_method_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == GetValue(3));

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_constant_add_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 7,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == 4 + 3);

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_greater_or_equal_than_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 1,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn >= 1);

			Assert.IsNotNull(actual);
			Assert.AreEqual(11, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_unary_not_constant_expression2()
		{
			var expected = new TestType()
				               {
					               IntColumn = 12,
					               BoolColumn = false,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => !q.BoolColumn);

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_using_contains_with_backtick_in_string()
		{
			var stringVal = "string`ContainingAQuote";

			var expected = new TestType()
				               {
					               IntColumn = 7,
					               BoolColumn = true,
					               StringColumn = stringVal
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.StringColumn.Contains(stringVal));

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_equals_variable_int_expression()
		{
// ReSharper disable ConvertToConstant.Local
			var columnValue = 3;
// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = columnValue,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == columnValue);

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_evaluated_conditional_or_expression()
		{
			// ReSharper disable ConvertToConstant.Local
			var a = 10;
			var b = 5;
			// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == 3 || a > b);

			Assert.IsNotNull(actual);
			Assert.AreEqual(11, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_logical_xor_variable_expression()
		{
			// ReSharper disable ConvertToConstant.Local
			var a = true;
			var b = false;
			// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = 12,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.BoolColumn == (a ^ b));

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_not_equals_null_espression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 12,
					               BoolColumn = false,
					               StringColumn = "test",
					               NullableCol = new TestType {StringColumn = "sometext"}
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.NullableCol != null);

			Assert.IsNotNull(actual);
			Assert.AreEqual(actual.Count, 1);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_equals_constant_bool_expression2()
		{
			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			// ReSharper disable RedundantBoolCompare
			var actual = OpenDbConnection().Select<TestType>(q => q.BoolColumn);
			// ReSharper restore RedundantBoolCompare

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_using_startsWith()
		{
			var prefix = "prefix";

			var expected = new TestType()
				               {
					               IntColumn = 7,
					               BoolColumn = true,
					               StringColumn = prefix + "asdfasdfasdf"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.StringColumn.StartsWith(prefix));

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_variablemodulo_expression()
		{
			// ReSharper disable ConvertToConstant.Local
			var a = 37;
			var b = 10;
			// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = 7,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == a%b);

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_unary_cast_variable_with_implicit_userdefined_type_conversion_expression()
		{
			// ReSharper disable ConvertToConstant.Local
			var intVal = 12;
			// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = 12,
					               BoolColumn = true,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var value = new IntWrapper(intVal);

			var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == value);

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_logical_and_method_expression()
		{
			var expected = new TestType()
				               {
					               IntColumn = 12,
					               BoolColumn = false,
					               StringColumn = "test"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.BoolColumn == (GetValue(true) & GetValue(false)));

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_evaluated_invalid_conditional_or_valid_expression()
		{
			// ReSharper disable ConvertToConstant.Local
			var a = true;
			// ReSharper restore ConvertToConstant.Local

			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => !q.BoolColumn || a);

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_using_endsWith_with_backtick_in_string()
		{
			var postfix = "postfix";

			var expected = new TestType()
				               {
					               IntColumn = 7,
					               BoolColumn = true,
					               StringColumn = "asdfasd`fasdf" + postfix
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.StringColumn.EndsWith(postfix));

			Assert.IsNotNull(actual);
			Assert.AreEqual(1, actual.Count);
			CollectionAssert.Contains(actual, expected);
		}
		public void Can_select_evaluated_conditional_and_valid_expression()
		{
			var model = new
				            {
					            StringValue = "4"
				            };

			var expected = new TestType()
				               {
					               IntColumn = 3,
					               BoolColumn = true,
					               StringColumn = "4"
				               };

			EstablishContext(10, expected);

			var actual = OpenDbConnection().Select<TestType>(q => q.BoolColumn && q.StringColumn == model.StringValue);

			Assert.IsNotNull(actual);
			Assert.Greater(actual.Count, 0);
			CollectionAssert.Contains(actual, expected);
		}