public ExpressionTest()
{
_db = new AppDb();
// initialize simple data types
_simple = new DataTypesSimple
{
TypeDateTime = new DateTime(2017, 1, 1, 0, 0, 0),
TypeDouble = 3.1415,
TypeDoubleN = -3.1415
};
_db.DataTypesSimple.Add(_simple);
// initialize simple data types
_simple2 = new DataTypesSimple
{
TypeDouble = 1,
TypeDoubleN = -1
};
_db.DataTypesSimple.Add(_simple2);
// initialize variable data types
_variable = DataTypesVariable.CreateEmpty();
_variable.TypeString = "EntityFramework";
_db.DataTypesVariable.Add(_variable);
_db.SaveChanges();
}
private void TestValue(DataTypesSimple valueDb)
{
// bool
Assert.Equal(true, valueDb.TypeBool);
// nullable bool
Assert.Equal(true, valueDb.TypeBoolN);
// integers
Assert.Equal(short.MinValue, valueDb.TypeShort);
Assert.Equal(int.MinValue, valueDb.TypeInt);
Assert.Equal(long.MinValue, valueDb.TypeLong);
// nullable integers
Assert.Equal(short.MinValue, valueDb.TypeShortN);
Assert.Equal(int.MinValue, valueDb.TypeIntN);
Assert.Equal(long.MinValue, valueDb.TypeLongN);
// decimals
Assert.Equal(26768.124M, valueDb.TypeDecimal);
Assert.Equal(double.MaxValue, valueDb.TypeDouble);
Assert.InRange(valueDb.TypeFloat, TestFloat * (1 - 7e-1), TestFloat * (1 + 7e-1)); // floats have 7 digits of precision
// nullable decimals
Assert.Equal(3.1416M, valueDb.TypeDecimalN);
Assert.Equal(double.MaxValue, valueDb.TypeDoubleN);
Assert.InRange(valueDb.TypeFloatN.GetValueOrDefault(), TestFloat * (1 - 7e-1), TestFloat * (1 + 7e-1)); // floats have 7 digits of precision
// byte
Assert.Equal(TestSbyte, valueDb.TypeSbyte);
Assert.Equal(TestByte, valueDb.TypeByte);
Assert.Equal(TestChar, valueDb.TypeChar);
// nullable byte
Assert.Equal(TestSbyte, valueDb.TypeSbyte);
Assert.Equal(TestByte, valueDb.TypeByteN);
Assert.Equal(TestChar, valueDb.TypeCharN);
// DateTime
Assert.Equal(_dateTime, valueDb.TypeDateTime);
//Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffset);
//Assert.Equal(timeSpan, valueDb.TypeTimeSpan);
// nullable DateTime
Assert.Equal(_dateTime, valueDb.TypeDateTimeN);
//Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffsetN);
//Assert.Equal(timeSpan, valueDb.TypeTimeSpanN);
// Enum
Assert.Equal(TestEnum, valueDb.TypeEnum);
Assert.Equal(TestEnumByte, valueDb.TypeEnumByte);
// nullable Enum
Assert.Equal(TestEnum, valueDb.TypeEnumN);
Assert.Equal(TestEnumByte, valueDb.TypeEnumByteN);
// guid
//Assert.Equal(_guid, valueDb.TypeGuid);
// nullable guid
//Assert.Equal(_guid, valueDb.TypeGuidN);
}
private static void TestEmpty(DataTypesSimple emptyDb)
{
// bool
Assert.Equal(default(bool), emptyDb.TypeBool);
// nullable bool
// Assert.Equal(null, emptyDb.TypeBoolN);
// integers
Assert.Equal(default(short), emptyDb.TypeShort);
Assert.Equal(default(int), emptyDb.TypeInt);
Assert.Equal(default(long), emptyDb.TypeLong);
// nullable integers
Assert.Equal(null, emptyDb.TypeShortN);
Assert.Equal(null, emptyDb.TypeIntN);
Assert.Equal(null, emptyDb.TypeLongN);
// decimals
Assert.Equal(default(decimal), emptyDb.TypeDecimal);
Assert.Equal(default(double), emptyDb.TypeDouble);
Assert.Equal(default(float), emptyDb.TypeFloat);
// nullable decimals
Assert.Equal(null, emptyDb.TypeDecimalN);
Assert.Equal(null, emptyDb.TypeDoubleN);
Assert.Equal(null, emptyDb.TypeFloatN);
// byte
Assert.Equal(default(sbyte), emptyDb.TypeSbyte);
Assert.Equal(default(byte), emptyDb.TypeByte);
Assert.Equal(default(char), emptyDb.TypeChar);
// nullable byte
Assert.Equal(null, emptyDb.TypeSbyteN);
Assert.Equal(null, emptyDb.TypeByteN);
Assert.Equal(null, emptyDb.TypeCharN);
// DateTime
Assert.Equal(default(DateTime), emptyDb.TypeDateTime);
//Assert.Equal(default(DateTimeOffset), emptyDb.TypeDateTimeOffset);
//Assert.Equal(default(TimeSpan), emptyDb.TypeTimeSpan);
// nullable DateTime
//Assert.Equal(null, emptyDb.TypeDateTimeN);
//Assert.Equal(null, emptyDb.TypeDateTimeOffsetN);
//Assert.Equal(null, emptyDb.TypeTimeSpanN);
// Enum
Assert.Equal(default(TestEnum), emptyDb.TypeEnum);
Assert.Equal(default(TestEnumByte), emptyDb.TypeEnumByte);
// nullableEnum
Assert.Equal(null, emptyDb.TypeEnumN);
Assert.Equal(null, emptyDb.TypeEnumByteN);
// guid
//Assert.Equal(default(Guid), emptyDb.TypeGuid);
// nullable guid
//Assert.Equal(null, emptyDb.TypeGuidN);
}
public void TestSimpleTypesEmpty()
{
// Create test data objects
var emptyMemSync = new DataTypesSimple();
// Save them to the database
using (var db = new AppDb())
{
db.DataTypesSimple.Add(emptyMemSync);
db.SaveChanges();
}
// Load them from the database and run tests
using (var db = new AppDb())
{
var item = db.DataTypesSimple.FirstOrDefault(x => x.Id == emptyMemSync.Id);
TestEmpty(item);
}
}
public async Task TestSimpleTypesEmptyAsync()
{
// Create test data objects
var emptyMemAsync = new DataTypesSimple();
// Save them to the database
using (var db = new AppDb())
{
db.DataTypesSimple.Add(emptyMemAsync);
await db.SaveChangesAsync();
}
// Load them from the database and run tests
using (var db = new AppDb())
{
// ReSharper disable once AccessToDisposedClosure
async Task <DataTypesSimple> FromDbAsync(DataTypesSimple dt) => await db.DataTypesSimple.FirstOrDefaultAsync(m => m.Id == dt.Id);
TestEmpty(await FromDbAsync(emptyMemAsync));
}
}
public async Task TestDataTypesSimple()
{
void TestEmpty(DataTypesSimple emptyDb)
{
// bool
Assert.Equal(default(bool), emptyDb.TypeBool);
// nullable bool
Assert.Equal(null, emptyDb.TypeBoolN);
// integers
Assert.Equal(default(short), emptyDb.TypeShort);
Assert.Equal(default(ushort), emptyDb.TypeUshort);
Assert.Equal(default(int), emptyDb.TypeInt);
Assert.Equal(default(uint), emptyDb.TypeUint);
Assert.Equal(default(long), emptyDb.TypeLong);
Assert.Equal(default(ulong), emptyDb.TypeUlong);
// nullable integers
Assert.Equal(null, emptyDb.TypeShortN);
Assert.Equal(null, emptyDb.TypeUshortN);
Assert.Equal(null, emptyDb.TypeIntN);
Assert.Equal(null, emptyDb.TypeUintN);
Assert.Equal(null, emptyDb.TypeLongN);
Assert.Equal(null, emptyDb.TypeUlongN);
// decimals
Assert.Equal(default(decimal), emptyDb.TypeDecimal);
Assert.Equal(default(double), emptyDb.TypeDouble);
Assert.Equal(default(float), emptyDb.TypeFloat);
// nullable decimals
Assert.Equal(null, emptyDb.TypeDecimalN);
Assert.Equal(null, emptyDb.TypeDoubleN);
Assert.Equal(null, emptyDb.TypeFloatN);
// byte
Assert.Equal(default(sbyte), emptyDb.TypeSbyte);
Assert.Equal(default(byte), emptyDb.TypeByte);
Assert.Equal(default(char), emptyDb.TypeChar);
// nullable byte
Assert.Equal(null, emptyDb.TypeSbyteN);
Assert.Equal(null, emptyDb.TypeByteN);
Assert.Equal(null, emptyDb.TypeCharN);
// DateTime
Assert.Equal(default(DateTime), emptyDb.TypeDateTime);
Assert.Equal(default(DateTimeOffset), emptyDb.TypeDateTimeOffset);
Assert.Equal(default(TimeSpan), emptyDb.TypeTimeSpan);
// nullable DateTime
Assert.Equal(null, emptyDb.TypeDateTimeN);
Assert.Equal(null, emptyDb.TypeDateTimeOffsetN);
Assert.Equal(null, emptyDb.TypeTimeSpanN);
// Enum
Assert.Equal(default(TestEnum), emptyDb.TypeEnum);
Assert.Equal(default(TestEnumByte), emptyDb.TypeEnumByte);
// nullableEnum
Assert.Equal(null, emptyDb.TypeEnumN);
Assert.Equal(null, emptyDb.TypeEnumByteN);
// guid
Assert.Equal(default(Guid), emptyDb.TypeGuid);
// nullable guid
Assert.Equal(null, emptyDb.TypeGuidN);
}
const sbyte testSbyte = (sbyte)-128;
const byte testByte = (byte)255;
const char testChar = 'a';
const float testFloat = (float)1.23456789e38;
var dateTime = new DateTime(2016, 10, 11, 1, 2, 3, 456);
var dateTimeOffset = dateTime + TimeSpan.FromMilliseconds(123.456);
var timeSpan = new TimeSpan(1, 2, 3, 4, 5);
const TestEnum testEnum = TestEnum.TestOne;
const TestEnumByte testEnumByte = TestEnumByte.TestOne;
var guid = Guid.NewGuid();
// test each data type with a valid value
// ReSharper disable once ObjectCreationAsStatement
DataTypesSimple NewValueMem() => new DataTypesSimple
{
// bool
TypeBool = true,
// nullable bool
TypeBoolN = true,
// integers
TypeShort = short.MinValue,
TypeUshort = ushort.MaxValue,
TypeInt = int.MinValue,
TypeUint = uint.MaxValue,
TypeLong = long.MinValue,
TypeUlong = ulong.MaxValue,
// nullable integers
TypeShortN = short.MinValue,
TypeUshortN = ushort.MaxValue,
TypeIntN = int.MinValue,
TypeUintN = uint.MaxValue,
TypeLongN = long.MinValue,
TypeUlongN = ulong.MaxValue,
// decimals
TypeDecimal = decimal.MaxValue,
TypeDouble = double.MaxValue,
TypeFloat = testFloat,
// nullable decimals
TypeDecimalN = decimal.MaxValue,
TypeDoubleN = double.MaxValue,
TypeFloatN = testFloat,
// byte
TypeSbyte = testSbyte,
TypeByte = testByte,
TypeChar = testChar,
// nullable byte
TypeSbyteN = testSbyte,
TypeByteN = testByte,
TypeCharN = testChar,
// DateTime
TypeDateTime = dateTime,
TypeDateTimeOffset = dateTimeOffset,
TypeTimeSpan = timeSpan,
// nullable DateTime
TypeDateTimeN = dateTime,
TypeDateTimeOffsetN = dateTimeOffset,
TypeTimeSpanN = timeSpan,
// Enum
TypeEnum = testEnum,
TypeEnumByte = testEnumByte,
// nullable Enum
TypeEnumN = testEnum,
TypeEnumByteN = testEnumByte,
// guid
TypeGuid = guid,
// nullable guid
TypeGuidN = guid,
};
void TestValue(DataTypesSimple valueDb)
{
// bool
Assert.Equal(true, valueDb.TypeBool);
// nullable bool
Assert.Equal(true, valueDb.TypeBoolN);
// integers
Assert.Equal(short.MinValue, valueDb.TypeShort);
Assert.Equal(ushort.MaxValue, valueDb.TypeUshort);
Assert.Equal(int.MinValue, valueDb.TypeInt);
Assert.Equal(uint.MaxValue, valueDb.TypeUint);
Assert.Equal(long.MinValue, valueDb.TypeLong);
Assert.Equal(ulong.MaxValue, valueDb.TypeUlong);
// nullable integers
Assert.Equal(short.MinValue, valueDb.TypeShortN);
Assert.Equal(ushort.MaxValue, valueDb.TypeUshortN);
Assert.Equal(int.MinValue, valueDb.TypeIntN);
Assert.Equal(uint.MaxValue, valueDb.TypeUintN);
Assert.Equal(long.MinValue, valueDb.TypeLongN);
Assert.Equal(ulong.MaxValue, valueDb.TypeUlongN);
// decimals
Assert.Equal(decimal.MaxValue, valueDb.TypeDecimal);
Assert.Equal(double.MaxValue, valueDb.TypeDouble);
Assert.InRange(valueDb.TypeFloat, testFloat * (1 - 7e-1), testFloat * (1 + 7e-1)); // floats have 7 digits of precision
// nullable decimals
Assert.Equal(decimal.MaxValue, valueDb.TypeDecimalN);
Assert.Equal(double.MaxValue, valueDb.TypeDoubleN);
Assert.InRange(valueDb.TypeFloatN.GetValueOrDefault(), testFloat * (1 - 7e-1), testFloat * (1 + 7e-1)); // floats have 7 digits of precision
// byte
Assert.Equal(testSbyte, valueDb.TypeSbyte);
Assert.Equal(testByte, valueDb.TypeByte);
Assert.Equal(testChar, valueDb.TypeChar);
// nullable byte
Assert.Equal(testSbyte, valueDb.TypeSbyte);
Assert.Equal(testByte, valueDb.TypeByteN);
Assert.Equal(testChar, valueDb.TypeCharN);
// DateTime
Assert.Equal(dateTime, valueDb.TypeDateTime);
Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffset);
Assert.Equal(timeSpan, valueDb.TypeTimeSpan);
// nullable DateTime
Assert.Equal(dateTime, valueDb.TypeDateTimeN);
Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffsetN);
Assert.Equal(timeSpan, valueDb.TypeTimeSpanN);
// Enum
Assert.Equal(testEnum, valueDb.TypeEnum);
Assert.Equal(testEnumByte, valueDb.TypeEnumByte);
// nullable Enum
Assert.Equal(testEnum, valueDb.TypeEnumN);
Assert.Equal(testEnumByte, valueDb.TypeEnumByteN);
// guid
Assert.Equal(guid, valueDb.TypeGuid);
// nullable guid
Assert.Equal(guid, valueDb.TypeGuidN);
}
// create test data objects
var emptyMemAsync = new DataTypesSimple();
var emptyMemSync = new DataTypesSimple();
var valueMemAsync = NewValueMem();
var valueMemSync = NewValueMem();
// save them to the database
using (var scope = new AppDbScope())
{
var db = scope.AppDb;
db.DataTypesSimple.Add(emptyMemAsync);
db.DataTypesSimple.Add(valueMemAsync);
await db.SaveChangesAsync();
db.DataTypesSimple.Add(emptyMemSync);
db.DataTypesSimple.Add(valueMemSync);
db.SaveChanges();
}
// load them from the database and run tests
using (var scope = new AppDbScope())
{
var db = scope.AppDb;
// ReSharper disable once AccessToDisposedClosure
async Task <DataTypesSimple> FromDbAsync(DataTypesSimple dt) => await db.DataTypesSimple.FirstOrDefaultAsync(m => m.Id == dt.Id);
// ReSharper disable once AccessToDisposedClosure
DataTypesSimple FromDbSync(DataTypesSimple dt) => db.DataTypesSimple.FirstOrDefault(m => m.Id == dt.Id);
TestEmpty(await FromDbAsync(emptyMemAsync));
TestEmpty(FromDbSync(emptyMemSync));
TestValue(await FromDbAsync(valueMemAsync));
TestValue(FromDbSync(valueMemSync));
}
}
public async Task TestDataTypesSimple()
{
Action <DataTypesSimple> testEmpty = emptyDb =>
{
// integers
Assert.Equal(default(short), emptyDb.TypeShort);
Assert.Equal(default(ushort), emptyDb.TypeUshort);
Assert.Equal(default(int), emptyDb.TypeInt);
Assert.Equal(default(uint), emptyDb.TypeUint);
Assert.Equal(default(long), emptyDb.TypeLong);
Assert.Equal(default(ulong), emptyDb.TypeUlong);
// nullable integers
Assert.Equal(null, emptyDb.TypeShortN);
Assert.Equal(null, emptyDb.TypeUshortN);
Assert.Equal(null, emptyDb.TypeIntN);
Assert.Equal(null, emptyDb.TypeUintN);
Assert.Equal(null, emptyDb.TypeLongN);
Assert.Equal(null, emptyDb.TypeUlongN);
// decimals
Assert.Equal(default(decimal), emptyDb.TypeDecimal);
Assert.Equal(default(double), emptyDb.TypeDouble);
Assert.Equal(default(float), emptyDb.TypeFloat);
// nullable decimals
Assert.Equal(null, emptyDb.TypeDecimalN);
Assert.Equal(null, emptyDb.TypeDoubleN);
Assert.Equal(null, emptyDb.TypeFloatN);
// byte
Assert.Equal(default(sbyte), emptyDb.TypeSbyte);
Assert.Equal(default(byte), emptyDb.TypeByte);
Assert.Equal(default(char), emptyDb.TypeChar);
// nullable byte
Assert.Equal(null, emptyDb.TypeSbyteN);
Assert.Equal(null, emptyDb.TypeByteN);
Assert.Equal(null, emptyDb.TypeCharN);
// DateTime
Assert.Equal(default(DateTime), emptyDb.TypeDateTime);
Assert.Equal(default(DateTimeOffset), emptyDb.TypeDateTimeOffset);
// nullable DateTime
Assert.Equal(null, emptyDb.TypeDateTimeN);
Assert.Equal(null, emptyDb.TypeDateTimeOffsetN);
// guid
Assert.Equal(default(Guid), emptyDb.TypeGuid);
// nullable guid
Assert.Equal(null, emptyDb.TypeGuidN);
};
const sbyte testSbyte = (sbyte)-128;
const byte testByte = (byte)255;
const char testChar = 'a';
const float testFloat = (float)1.23456789e38;
// by default, we use second granularity on dateTime
var dateTime = new DateTime(2016, 10, 6, 13, 3, 7);
// we only support up to millisecond granularity on dateTimeOffset
var dateTimeOffset = new DateTime(2016, 10, 6) + TimeSpan.FromMilliseconds(123456789);
var guid = Guid.NewGuid();
// test each data type with a valid value
// ReSharper disable once ObjectCreationAsStatement
Func <DataTypesSimple> newValueMem = () => new DataTypesSimple {
// integers
TypeShort = short.MinValue,
TypeUshort = ushort.MaxValue,
TypeInt = int.MinValue,
TypeUint = uint.MaxValue,
TypeLong = long.MinValue,
TypeUlong = ulong.MaxValue,
// nullable integers
TypeShortN = short.MinValue,
TypeUshortN = ushort.MaxValue,
TypeIntN = int.MinValue,
TypeUintN = uint.MaxValue,
TypeLongN = long.MinValue,
TypeUlongN = ulong.MaxValue,
// decimals
TypeDecimal = decimal.MaxValue,
TypeDouble = double.MaxValue,
TypeFloat = testFloat,
// nullable decimals
TypeDecimalN = decimal.MaxValue,
TypeDoubleN = double.MaxValue,
TypeFloatN = testFloat,
// byte
TypeSbyte = testSbyte,
TypeByte = testByte,
TypeChar = testChar,
// nullable byte
TypeSbyteN = testSbyte,
TypeByteN = testByte,
TypeCharN = testChar,
// DateTime
TypeDateTime = dateTime,
TypeDateTimeOffset = dateTimeOffset,
// nullable DateTime
TypeDateTimeN = dateTime,
TypeDateTimeOffsetN = dateTimeOffset,
// guid
TypeGuid = guid,
// nullable guid
TypeGuidN = guid,
};
Action <DataTypesSimple> testValue = valueDb =>
{
// integers
Assert.Equal(short.MinValue, valueDb.TypeShort);
Assert.Equal(ushort.MaxValue, valueDb.TypeUshort);
Assert.Equal(int.MinValue, valueDb.TypeInt);
Assert.Equal(uint.MaxValue, valueDb.TypeUint);
Assert.Equal(long.MinValue, valueDb.TypeLong);
Assert.Equal(ulong.MaxValue, valueDb.TypeUlong);
// nullable integers
Assert.Equal(short.MinValue, valueDb.TypeShortN);
Assert.Equal(ushort.MaxValue, valueDb.TypeUshortN);
Assert.Equal(int.MinValue, valueDb.TypeIntN);
Assert.Equal(uint.MaxValue, valueDb.TypeUintN);
Assert.Equal(long.MinValue, valueDb.TypeLongN);
Assert.Equal(ulong.MaxValue, valueDb.TypeUlongN);
// decimals
Assert.Equal(decimal.MaxValue, valueDb.TypeDecimal);
Assert.Equal(double.MaxValue, valueDb.TypeDouble);
Assert.InRange(valueDb.TypeFloat, testFloat * (1 - 7e-1), testFloat * (1 + 7e-1)); // floats have 7 digits of precision
// nullable decimals
Assert.Equal(decimal.MaxValue, valueDb.TypeDecimalN);
Assert.Equal(double.MaxValue, valueDb.TypeDoubleN);
Assert.InRange(valueDb.TypeFloatN.GetValueOrDefault(), testFloat * (1 - 7e-1), testFloat * (1 + 7e-1)); // floats have 7 digits of precision
// byte
Assert.Equal(testSbyte, valueDb.TypeSbyte);
Assert.Equal(testByte, valueDb.TypeByte);
Assert.Equal(testChar, valueDb.TypeChar);
// nullable byte
Assert.Equal(testSbyte, valueDb.TypeSbyte);
Assert.Equal(testByte, valueDb.TypeByteN);
Assert.Equal(testChar, valueDb.TypeCharN);
// DateTime
Assert.Equal(dateTime, valueDb.TypeDateTime);
Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffset);
// nullable DateTime
Assert.Equal(dateTime, valueDb.TypeDateTimeN);
Assert.Equal(dateTimeOffset, valueDb.TypeDateTimeOffsetN);
// guid
Assert.Equal(guid, valueDb.TypeGuid);
// nullable guid
Assert.Equal(guid, valueDb.TypeGuidN);
};
// create test data objects
var emptyMemAsync = new DataTypesSimple();
var emptyMemSync = new DataTypesSimple();
var valueMemAsync = newValueMem();
var valueMemSync = newValueMem();
// save them to the database
using (var db = new AppDb()){
db.DataTypesSimple.Add(emptyMemAsync);
db.DataTypesSimple.Add(valueMemAsync);
await db.SaveChangesAsync();
db.DataTypesSimple.Add(emptyMemSync);
db.DataTypesSimple.Add(valueMemSync);
db.SaveChanges();
}
// load them from the database and run tests
using (var db = new AppDb())
{
// ReSharper disable once AccessToDisposedClosure
Func <DataTypesSimple, Task <DataTypesSimple> > fromDbAsync =
async dt => await db.DataTypesSimple.FirstOrDefaultAsync(m => m.Id == dt.Id);
// ReSharper disable once AccessToDisposedClosure
Func <DataTypesSimple, DataTypesSimple> fromDbSync =
dt => db.DataTypesSimple.FirstOrDefault(m => m.Id == dt.Id);
testEmpty(await fromDbAsync(emptyMemAsync));
testEmpty(fromDbSync(emptyMemSync));
testValue(await fromDbAsync(valueMemAsync));
testValue(fromDbSync(valueMemSync));
}
}
