public void Can_select_evaluated_conditional_and_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);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.BoolColumn == (a >= b && a > 0));
Assert.IsNotNull(actual);
Assert.Greater(actual.Count, 0);
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);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.BoolColumn == (a ^ b));
Assert.IsNotNull(actual);
Assert.Greater(actual.Count, 0);
CollectionAssert.Contains(actual, expected);
}
}
public void Can_select_variable_add_expression()
{
// ReSharper disable ConvertToConstant.Local
var a = 4;
var b = 3;
// ReSharper restore ConvertToConstant.Local
var expected = new TestType
{
IntColumn = 7,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.IntColumn == a + b);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
CollectionAssert.Contains(actual, expected);
}
}
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_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_conditional_and_expression()
{
var expected = new TestType()
{
IntColumn = 3,
BoolColumn = true,
StringColumn = "4"
};
EstablishContext(10, expected);
var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn > 2 && q.IntColumn < 4);
Assert.IsNotNull(actual);
Assert.AreEqual(1, 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_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_unary_plus_constant_expression()
{
var expected = new TestType()
{
IntColumn = 12,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == +12);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
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_conditional_or_expression()
{
var expected = new TestType
{
IntColumn = 3,
BoolColumn = true,
StringColumn = "4"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.IntColumn == 3 || q.IntColumn < 0);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
CollectionAssert.Contains(actual, expected);
}
}
public void Can_select_greater_than_expression()
{
var expected = new TestType
{
IntColumn = 1,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.IntColumn > 1);
Assert.IsNotNull(actual);
Assert.AreEqual(10, actual.Count);
CollectionAssert.DoesNotContain(actual, expected);
}
}
public void Can_select_constant_multiply_expression()
{
var expected = new TestType
{
IntColumn = 12,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.IntColumn == 4 * 3);
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_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_method_modulo_expression()
{
var expected = new TestType
{
IntColumn = 7,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.IntColumn == GetValue(37) % GetValue(10));
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
CollectionAssert.Contains(actual, expected);
}
}
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_unary_cast_variable_expression()
{
// ReSharper disable ConvertToConstant.Local
object intVal = 12;
// ReSharper restore ConvertToConstant.Local
var expected = new TestType()
{
IntColumn = 12,
BoolColumn = true,
StringColumn = "test"
};
EstablishContext(10, expected);
var actual = OpenDbConnection().Select<TestType>(q => q.IntColumn == (int)intVal);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
CollectionAssert.Contains(actual, expected);
}
public void Can_select_unary_not_variable_expression()
{
// ReSharper disable ConvertToConstant.Local
var boolVal = true;
// ReSharper restore ConvertToConstant.Local
var expected = new TestType()
{
IntColumn = 12,
BoolColumn = false,
StringColumn = "test"
};
EstablishContext(10, expected);
var actual = OpenDbConnection().Select<TestType>(q => q.BoolColumn == !boolVal);
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_equals_constant_bool_expression2()
{
var expected = new TestType
{
IntColumn = 3,
BoolColumn = true,
StringColumn = "4"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.BoolColumn);
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);
using (var db = OpenDbConnection())
{
var actual = db.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);
}
public void Can_select_using_startsWith_with_double_quote_in_string()
{
var prefix = "prefix";
var expected = new TestType()
{
IntColumn = 7,
BoolColumn = true,
StringColumn = prefix + "\"asdfasdfasdf"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.StringColumn.StartsWith(prefix));
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
CollectionAssert.Contains(actual, expected);
}
}
public void Can_select_equals_variable_bool_expression()
{
// ReSharper disable ConvertToConstant.Local
var columnValue = true;
// ReSharper restore ConvertToConstant.Local
var expected = new TestType()
{
IntColumn = 3,
BoolColumn = true,
StringColumn = "4"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.BoolColumn == columnValue);
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);
using (var db = OpenDbConnection())
{
var actual = db.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_unary_not_method_expression()
{
var expected = new TestType
{
IntColumn = 12,
BoolColumn = false,
StringColumn = "test"
};
EstablishContext(10, expected);
using (var db = OpenDbConnection())
{
var actual = db.Select<TestType>(q => q.BoolColumn == !GetValue(true));
Assert.IsNotNull(actual);
Assert.Greater(actual.Count, 0);
CollectionAssert.Contains(actual, expected);
}
}
