public void Test12()
{
throw new Exception("Этот тест входит в бесконечный цикл и роняет систему прогонки тестов");
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.CAR.AddObject(new CAR { CAR_ID = 1 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 1, DOOR_ID = 10 });
var cars =
(from car in dataModel.CAR
select new Container { Id2 = (int?)car.CAR_ID });
cars = cars.Union(new[] { new Container { Id2 = null } });
var doors =
from door in dataModel.DOOR
select new { DoorId = door.DOOR_ID, Cars = cars.Where(car => car.Id2 == door.CAR_ID) };
var finalDoors =
(from door in dataModel.DOOR
where doors.Any(d => d.Cars.Any(c => c.Id2 == door.CAR_ID))
select door).ToList();
Assert.AreEqual(1, finalDoors.Count);
}
public static void Should_Return_CorrectOutput_With_OKStatus_For_DoubleInput(TestDataModel <double> model, string fileName)
{
Skip.If(model.Skip, "Test has been skipped in configuration");
const double equalityTolerance = 0.001d;
Indicators.IndicatorsDefinition.ShouldContainKey(model.Name, $"Cannot find definition for '{model.Name}");
var indicator = Indicators.IndicatorsDefinition[model.Name];
model.Options.Length.ShouldBe(indicator.Options.Length, "Number of options must match the definition");
var inputOffset = indicator.Start(model.Options);
model.Inputs.Length.ShouldBe(indicator.Inputs.Length, "Number of inputs must match the definition");
var outputLength = model.Inputs[0].Length - inputOffset;
outputLength.ShouldBePositive("Output array should have the correct length");
var resultOutput = new double[model.Outputs.Length][];
resultOutput.Length.ShouldBe(indicator.Outputs.Length, "Number of outputs must match the definition");
for (var i = 0; i < resultOutput.Length; i++)
{
resultOutput[i] = new double[outputLength];
}
var returnCode = indicator.Run(model.Inputs, model.Options, resultOutput);
returnCode.ShouldBe(0, "Function should complete with success status code TI_OK(0)");
for (var i = 0; i < resultOutput.Length; i++)
{
resultOutput[i].Length.ShouldBe(model.Outputs[i].Length, "Expected and calculated length of the output arrays should be equal");
resultOutput[i].ShouldBe(model.Outputs[i], equalityTolerance);
}
}
private void ExecuteGroupBy(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
dataModel.DOOR.AddObject(new DOOR {
DOOR_ID = 1
});
dataModel.DOOR.AddObject(new DOOR {
DOOR_ID = 2
});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {
DOOR_HANDLE_ID = 1, DOOR_ID = 1, COLOR = "YELLOW"
});
var minIdDoors =
(from door in dataModel.DOOR
join doorHandle in dataModel.DOOR_HANDLE on door.DOOR_ID equals doorHandle.DOOR_ID into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
join doorHandle2 in dataModel.DOOR_HANDLE on doorHandle.DOOR_HANDLE_ID equals doorHandle2.DOOR_HANDLE_ID into joinedDoorHandle2 from doorHandle2 in joinedDoorHandle2.DefaultIfEmpty()
group new { doorHandle2, door } by doorHandle2.COLOR into groupedDoorHandle
select new { Id = groupedDoorHandle.Min(x => x.door.DOOR_ID), Color = groupedDoorHandle.Key }).ToList();
Assert.AreEqual(1, minIdDoors.First().Id);
Assert.AreEqual("YELLOW", minIdDoors.First().Color);
Assert.AreEqual(null, minIdDoors[1].Color);
}
public HttpResponseMessage PostTest([FromBody] TestDataModel model)
{
foreach (var subject in model.SubjectList)
{
if (_questionDal.GetAllQuestions().Count(q => q.CategoryId == subject.Id) < model.NumberOfQuestions)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { Message = " Number of questions to high " }));
}
}
var questionList = new List <Question>();
foreach (var subject in model.SubjectList)
{
var questions =
_questionDal.GetAllQuestions()
.Where(q => q.CategoryId == subject.Id)
.OrderBy(r => Guid.NewGuid())
.Take(model.NumberOfQuestions).ToList();
questionList.AddRange(questions);
}
var test = _testDal.AddTestWithQuestions(model.TestName, model.TestLevelId,
new TimeSpan(model.Hours, model.Minutes, model.Seconds), questionList);
return(Request.CreateResponse(HttpStatusCode.Created, new { Message = "Test has been created" }));
}
void ExecuteNullComparison(bool isSmart)
{
var dataModel = new TestDataModel { Settings = { IsSmart = isSmart } };
new[]
{
new DOOR_HANDLE {DOOR_HANDLE_ID = 1, MATERIAL_ID = 1, MANUFACTURER_ID = 1}, // <----
new DOOR_HANDLE {DOOR_HANDLE_ID = 2, MATERIAL_ID = 2, MANUFACTURER_ID = 2}, // |-- this is only pair
new DOOR_HANDLE {DOOR_HANDLE_ID = 3, MATERIAL_ID = 1, MANUFACTURER_ID = 1}, // <----
new DOOR_HANDLE {DOOR_HANDLE_ID = 4, MATERIAL_ID = 5, MANUFACTURER_ID = null},
new DOOR_HANDLE {DOOR_HANDLE_ID = 5, MATERIAL_ID = 5, MANUFACTURER_ID = null},
new DOOR_HANDLE {DOOR_HANDLE_ID = 6, MATERIAL_ID = null, MANUFACTURER_ID = null},
new DOOR_HANDLE {DOOR_HANDLE_ID = 7, MATERIAL_ID = null, MANUFACTURER_ID = null}
}
.ForEach(x => dataModel.DOOR_HANDLE.AddObject(x));
var handlePairsWithSameMaterialAndManufacturer =
(from handle in dataModel.DOOR_HANDLE
join anotherHandle in dataModel.DOOR_HANDLE on handle.MATERIAL_ID equals anotherHandle.MATERIAL_ID
where handle.MANUFACTURER_ID == anotherHandle.MANUFACTURER_ID && handle.DOOR_HANDLE_ID < anotherHandle.DOOR_HANDLE_ID
select new {handle, anotherHandle}).ToList();
Assert.AreEqual(1, handlePairsWithSameMaterialAndManufacturer.Count);
var pair = handlePairsWithSameMaterialAndManufacturer.First();
Assert.AreEqual(1, pair.handle.MATERIAL_ID);
Assert.AreEqual(pair.handle.MATERIAL_ID, pair.anotherHandle.MATERIAL_ID);
Assert.AreEqual(1, pair.handle.MANUFACTURER_ID);
Assert.AreEqual(pair.handle.MANUFACTURER_ID, pair.anotherHandle.MANUFACTURER_ID);
}
public async Task UpdateDatabase(TestDataModel project, UpdateTypeEnum updateType)
{
try
{
UpdateDataRequest request = new UpdateDataRequest()
{
Project = project,
UpdateType = new UpdateTypeModel()
{
Type = updateType
}
};
var response = (await TestDataServiceClient.UpdateDataRecordAsync(request));
if (!response.Result.IsValid)
{
_message = new MessageWindowModel()
{
Title = "Server error updating Data",
Message = response.Result.ErrorMessage,
};
}
// Refresh the Grid
await ReadHandler(_lastArgs);
}
catch (Exception ex)
{
_message = new MessageWindowModel()
{
Title = "Error Updating Data",
Message = ExHelper.GetExceptionText(ex),
};
}
}
public async Task <Result> HandleDataModelAsync(TestDataModel dataModel)
{
try
{
// data model already in the context
var local = _context.Set <TestDataModel>()
.Local
.FirstOrDefault(r => r.Name == dataModel.Name && r.Timestamp.CompareTo(dataModel.Timestamp) == 0);
if (local == default(TestDataModel))
{
local = await _context.DataModels !
.FirstOrDefaultAsync(r => r.Name == dataModel.Name && r.Timestamp.CompareTo(dataModel.Timestamp) == 0);
if (local == default(TestDataModel))
{
throw new InvalidOperationException("Test data model not found");
}
}
local.Property = DateTimeOffset.Now.ToString("o");
}
catch (Exception e)
{
Console.Error.WriteLine("Error occurred during handling data model {0} - {1}", e.Message, e.StackTrace);
return(Result.Error);
}
return(Result.Success);
}
public void Leaves_string_to_truncate_as_null_if_it_is_not_required()
{
var testDataModel = new TestDataModel();
DataStringPropertyHelper.ValidateString(testDataModel, m => m.TruncateMe);
Assert.IsNull(testDataModel.TruncateMe);
}
public void Test8()
{
var dataModel = new TestDataModel {
Settings = { IsSmart = true }
};
dataModel.DOOR.AddObject(new DOOR {
DOOR_ID = 100
});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {
MATERIAL_ID = 100
});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE());
var handles =
(from handle in dataModel.DOOR_HANDLE
select new { Id = handle.MATERIAL_ID.Value });
var doors =
from door in dataModel.DOOR
where handles.Any(handle => handle.Id == door.DOOR_ID)
select door;
Assert.AreEqual(1, doors.Count());
}
public void RequiredAttributeCheckerInternalCheckTest()
{
// arrange
var expectedFirstnameValid = GetConvertedTestValueAsBool(0) ?? throw new ApplicationException("Could not retrieve expected value.");
var expectedFirstnameErrorMessageKey = GetConvertedTestValueAsString(1);
var expectedLastnameValid = GetConvertedTestValueAsBool(2) ?? throw new ApplicationException("Could not retrieve expected value.");
var expectedLastnameErrorMessageKey = GetConvertedTestValueAsString(3);
var expectedFirstnameErrorMessage = string.IsNullOrEmpty(expectedFirstnameErrorMessageKey) ? string.Empty : TestResources.ResourceManager.GetString(expectedFirstnameErrorMessageKey);
var expectedLastnameErrorMessage = string.IsNullOrEmpty(expectedLastnameErrorMessageKey) ? string.Empty : TestResources.ResourceManager.GetString(expectedLastnameErrorMessageKey);
var item = new TestDataModel
{
Firstname = GetConvertedTestValueAsString(4),
Lastname = GetConvertedTestValueAsString(5),
Birthday = GetConvertedTestValueAsDateTime(6)
};
var checker = new RequiredAttributeChecker();
var firstNameAttribute = item.GetAttribute <RequiredAttribute>(nameof(TestDataModel.Firstname));
var lastNameAttribute = item.GetAttribute <RequiredAttribute>(nameof(TestDataModel.Lastname));
// act
var resultFirstname = checker.Check(firstNameAttribute, item.Firstname);
var resultLastname = checker.Check(lastNameAttribute, item.Lastname);
// assert
Assert.AreEqual(expectedFirstnameValid, resultFirstname.IsValid, "The validity check for firstname failed.");
Assert.AreEqual(expectedFirstnameErrorMessage, resultFirstname.ErrorMessage, "The error message for firstname is unexpected.");
Assert.AreEqual(expectedLastnameValid, resultLastname.IsValid, "The validity check for lastname failed.");
Assert.AreEqual(expectedLastnameErrorMessage, resultLastname.ErrorMessage, "The error message for lastname is unexpected.");
}
void ExecuteSelect(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
dataModel.CAR.AddObject(new CAR {
CAR_ID = 1
});
dataModel.CAR.AddObject(new CAR {
CAR_ID = 2
});
dataModel.DOOR.AddObject(new DOOR {
CAR_ID = 1, DOOR_ID = 1
});
dataModel.DOOR.AddObject(new DOOR {
CAR_ID = 2, DOOR_ID = 2
});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {
DOOR_ID = 1, DOOR_HANDLE_ID = 1, COLOR = "RED"
});
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on new { door.DOOR_ID } equals new { doorHandle.DOOR_ID }
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.COLOR != "RED" || doorHandle == null
select car).ToList();
Assert.AreEqual(1, carsWithoutRedHandle.Count);
Assert.AreEqual(2, carsWithoutRedHandle.First().CAR_ID);
}
private string AddNewRecord(TestDataModel addRecord)
{
string errorMessage = null;
try
{
var newRecord = new DataModel()
{
Id = _dataContext.TestData.Count + 1,
ColumnInt32 = addRecord.ColumnInt32,
ColumnDouble = addRecord.ColumnDouble,
ColumnFloat = (float)addRecord.ColumnFloat,
ColumnBool = addRecord.ColumnBool,
ColumnString = addRecord.ColumnString,
ColumnBytes = addRecord.ColumnBytes?.ToArray() ?? new byte[] { 0x20, 0x21, 0x22 },
ObjectId = addRecord.ColumnTestObject?.Id ?? 99,
ObjectDescription = addRecord.ColumnTestObject?.Description ?? "Add some Text",
Created = DateTime.Now,
Modified = DateTime.Now
};
_dataContext.TestData.Add(newRecord);
_dataContext.SaveChanges();
}
catch (Exception ex)
{
errorMessage = $"AddRecord error: {ExHelper.GetExceptionText(ex)}";
}
return(errorMessage);
}
public IHttpActionResult Put(int id, [FromBody] TestDataModel testModel)
{
if (!ModelState.IsValid)
{
return(this.BadRequest(ModelState));
}
var test = this.Data.Tests.SearchFor(t => t.Id == id).FirstOrDefault();
if (test == null)
{
return(this.BadRequest("Invalid id"));
}
var course = this.Data.Courses.SearchFor(c => c.Name == testModel.Course).FirstOrDefault();
if (course == null)
{
return(this.BadRequest("Invalid course name"));
}
test.Course = course;
this.Data.Tests.Update(test);
this.Data.SaveChanges();
return(this.Ok());
}
public void Test11()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.CAR.AddObject(new CAR { CAR_ID = 1 });
dataModel.CAR.AddObject(new CAR { CAR_ID = 2 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 2, DOOR_ID = 1 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 1, DOOR_ID = 10 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 2, DOOR_ID = 20 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 1, DOOR_ID = 12 });
var orderedIds =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
select new {car.CAR_ID, door.DOOR_ID})
.OrderBy(x => x.CAR_ID).ThenBy(x => x.DOOR_ID).ToList();
Assert.AreEqual(4, orderedIds.Count());
Assert.AreEqual(1, orderedIds[0].CAR_ID);
Assert.AreEqual(1, orderedIds[1].CAR_ID);
Assert.AreEqual(2, orderedIds[2].CAR_ID);
Assert.AreEqual(2, orderedIds[3].CAR_ID);
Assert.AreEqual(10, orderedIds[0].DOOR_ID);
Assert.AreEqual(12, orderedIds[1].DOOR_ID);
Assert.AreEqual(1, orderedIds[2].DOOR_ID);
Assert.AreEqual(20, orderedIds[3].DOOR_ID);
}
void ExecuteSumFromEmptyTable(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
int sum = dataModel.CAR.Sum(x => x.CAR_ID);
}
private string EditRecord(TestDataModel editRecord)
{
string errorMessage = null;
try
{
var dbRecord = GetRecord(editRecord.Id);
dbRecord.ColumnInt32 = editRecord.ColumnInt32;
dbRecord.ColumnDouble = editRecord.ColumnDouble;
dbRecord.ColumnFloat = (float)editRecord.ColumnFloat;
dbRecord.ColumnBool = editRecord.ColumnBool;
dbRecord.ColumnString = editRecord.ColumnString;
dbRecord.ColumnBytes = editRecord.ColumnBytes.ToArray();
dbRecord.ObjectId = editRecord.ColumnTestObject.Id;
dbRecord.ObjectDescription = editRecord.ColumnTestObject.Description;
dbRecord.Modified = DateTime.Now;
_dataContext.SaveChanges();
}
catch (Exception ex)
{
errorMessage = $"EditRecord error: {ExHelper.GetExceptionText(ex)}";
}
return(errorMessage);
}
void ExecuteTwoLeftJoins(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
const int carId = 100;
dataModel.CAR.AddObject(new CAR {
CAR_ID = carId
});
dataModel.CAR.AddObject(new CAR {
CAR_ID = carId + 1
});
var cars =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on door.DOOR_ID equals doorHandle.DOOR_ID
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
select car).ToList();
Assert.AreEqual(2, cars.Count);
Assert.AreEqual(carId, cars.First().CAR_ID);
}
public void ExecuteContains(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
new[]
{
new DOOR_HANDLE {
DOOR_HANDLE_ID = 1, MATERIAL_ID = 1
},
new DOOR_HANDLE {
DOOR_HANDLE_ID = 2, MATERIAL_ID = 2
},
new DOOR_HANDLE {
DOOR_HANDLE_ID = 3
}
}
.ForEach(dataModel.DOOR_HANDLE.AddObject);
var doorHandleIds = new List <int> {
1, 2
};
var doorHandles =
(from doorHandle in dataModel.DOOR_HANDLE
where doorHandleIds.Contains(doorHandle.MATERIAL_ID.Value)
select doorHandle).ToList();
Assert.AreEqual(2, doorHandles.Count);
}
public void Test9()
{
var dataModel = new TestDataModel {
Settings = { IsSmart = true }
};
dataModel.CAR.AddObject(new CAR {
CAR_ID = 1
});
dataModel.DOOR.AddObject(new DOOR {
CAR_ID = 1, DOOR_ID = 10
});
var cars =
(from car in dataModel.CAR
select new { CAR_ID = (int?)car.CAR_ID });
cars = cars.Union(new[] { new { CAR_ID = (int?)null } });
var doors =
from door in dataModel.DOOR
select new{ DoorId = door.DOOR_ID, Cars = cars.Where(car => car.CAR_ID == door.CAR_ID) };
var finalDoors =
(from door in dataModel.DOOR
where doors.Any(d => d.Cars.Any(c => c.CAR_ID == door.CAR_ID))
select door).ToList();
Assert.AreEqual(1, finalDoors.Count);
}
public void Test5()
{
var dataModel = new TestDataModel {
Settings = { IsSmart = true }
};
dataModel.CAR.AddObject(new CAR {
CAR_ID = 1
});
dataModel.CAR.AddObject(new CAR {
CAR_ID = 2
});
dataModel.DOOR.AddObject(new DOOR {
CAR_ID = 1, DOOR_ID = 1
});
dataModel.DOOR.AddObject(new DOOR {
CAR_ID = 2, DOOR_ID = 2
});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {
DOOR_ID = 1, DOOR_HANDLE_ID = 1, COLOR = "RED"
});
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor
from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on new { door.DOOR_ID } equals new { doorHandle.DOOR_ID }
into joinedDoorHandle
from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.COLOR != "RED" || doorHandle == null
select new{ car }).First();
Assert.AreEqual(2, carsWithoutRedHandle.car.CAR_ID);
}
public void Test2()
{
var dataModel = new TestDataModel {
Settings = { IsSmart = true }
};
dataModel.CAR.AddObject(new CAR {
CAR_ID = 1
});
dataModel.CAR.AddObject(new CAR {
CAR_ID = 2
});
var cars =
(from car in dataModel.CAR
select new { car.CAR_ID, Container = new Container {
Id = car.CAR_ID, Id2 = car.CAR_ID + 1, SubContainer = new Container {
Id = 5, SubContainer = new Container()
}
} }
)
.Where(x => x.Container.Id2 != 3)
.ToList();
var carExtended = cars.Single();
Assert.AreEqual(1, carExtended.CAR_ID);
Assert.AreEqual(1, carExtended.Container.Id);
Assert.AreEqual(2, carExtended.Container.Id2);
Assert.AreEqual(5, carExtended.Container.SubContainer.Id);
}
public void Test4()
{
var dataModel = new TestDataModel {
Settings = { IsSmart = true }
};
dataModel.CAR.Where(y => y.CAR_ID == dataModel.CAR.Select(x => x).Sum(x => x.CAR_ID)).ToList();
}
public void Create_calls_provider()
{
TestDataModel testDataModel = new TestDataModel();
_dataService.Create(testDataModel);
A.CallTo(() => _dataProvider.Query <int?>(A <string> .Ignored, A <ParameterCollection> .Ignored, CommandType.Text, A <Action <IDbConnection> > .Ignored)).MustHaveHappened();
}
/// <summary>
/// Retrieves a custom attribute for the given <paramref name="item" /> searching for a property by it's
/// <paramref name="propertyName" />.
/// </summary>
/// <typeparam name="T">The type of the custom attribute the caller searches for.</typeparam>
/// <param name="item">The target instance.</param>
/// <param name="propertyName">The name of the property.</param>
/// <returns>The custom attribute or <c>null</c> if no matching attribute was found.</returns>
public static T GetAttribute <T>(this TestDataModel item, string propertyName)
{
if (!(item.GetType().GetProperty(propertyName)?.GetCustomAttributes(typeof(T), true).FirstOrDefault() is T attribute))
{
throw new ApplicationException("No matching attribute found on test model.");
}
return(attribute);
}
// Insert in middle of structure test
public TestModel MidInsertTest(int newIterations, string structureName)
{
ReadFiles();
long memStart = 0, memEnd = 0;
for (int i = 1; i < newIterations + 1; i++)
{
// get pre-fill memory
memStart = GC.GetTotalMemory(true);
switch (structureName)
{
case "StringBuilder":
newTestModel.title = "StringBuilder";
newTestModel.method = ($"Insert a copy of War and Peace into middle of data structure; repeat {newIterations} times");
builderLarge = new StringBuilder();
sw.Start();
builderLarge.Insert(builderLarge.Length / 2, stringLong);
sw.Stop();
break;
case "BigList":
newTestModel.title = "BigList";
newTestModel.method = ($"Insert a copy of War and Peace into middle of data structure; repeat {newIterations} times");
biglistLarge = new BigList <string>();
sw.Start();
biglistLarge.Insert(biglistLarge.Count / 2, stringLong);
sw.Stop();
break;
case "Rope":
newTestModel.title = "Rope";
newTestModel.method = ($"Insert a copy of War and Peace into middle of data structure; repeat {newIterations} times");
ropeLarge = new Rope.Rope <string>();
sw.Start();
ropeLarge.AddRange(newArray, ropeLarge.Length / 2, newArray.Length);
sw.Stop();
break;
}
memEnd = GC.GetTotalMemory(false);
TestDataModel newTestData = new TestDataModel {
id = i, memory = (memEnd - memStart), time = sw.ElapsedTicks
};
// Gets sum of time and memory
averageTime += newTestData.time;
averageMemory += newTestData.memory;
newTestDataModel.Add(newTestData);
sw.Reset();
}
newTestModel.averageTime = averageTime / newIterations;
newTestModel.averageMemory = averageMemory / newIterations;
newTestModel.data = newTestDataModel;
return(newTestModel);
}
public void IntegrationTest()
{
var algo = new FetAlgorithm();
var model = new TestDataModel().MockDataModel;
var task = algo.GenerateTask("testIdentifier", model.Object, CancellationToken.None);
task.Wait();
Assert.IsInstanceOf <Timetable>(task.Result);
}
void ExecuteNullableSumFromEmptyTable(bool isSmart)
{
var dataModel = new TestDataModel {
Settings = { IsSmart = isSmart }
};
int?sum = dataModel.DOOR_HANDLE.Sum(x => x.MATERIAL_ID);
Assert.AreEqual(null, sum);
}
public void update_calls_provider()
{
object key = 5;
TestDataModel testDataModel = new TestDataModel();
_dataService.Update(key, testDataModel);
A.CallTo(() => _dataProvider.Execute(A <string> .Ignored, A <ParameterCollection> .Ignored, CommandType.Text, null)).MustHaveHappenedOnceExactly();
}
public void All_creates_view_model()
{
TestDataModel testDataModel = new TestDataModel();
A.CallTo(() => _dataProvider.All()).Returns(new[] { testDataModel });
_dataService.All().ToList();
A.CallTo(() => _modelFactory.CreateViewModel(testDataModel)).MustHaveHappenedOnceExactly();
}
public void ByKey_creates_view_model()
{
TestDataModel testDataModel = new TestDataModel();
const int key = 2;
A.CallTo(() => _dataProvider.ByKey(key)).Returns(testDataModel);
_dataService.ByKey(key);
A.CallTo(() => _modelFactory.CreateViewModel(testDataModel)).MustHaveHappenedOnceExactly();
}
public void Test()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
var door = new DOOR { CAR_ID = 1, DOOR_ID = 100};
dataModel.DOOR.AddObject(door);
dataModel.CAR.AddObject(new CAR {CAR_ID = 1, Doors = new EntityCollection<DOOR>(new []{door})});
var carByDoor = dataModel.CAR.Where(car => car.Doors.Any(d => d.DOOR_ID == 100)).FirstOrDefault();
Assert.NotNull(carByDoor);
}
public void Sets_null_required_string_property_to_empty()
{
var testDataModel = new TestDataModel();
Assert.IsNull(testDataModel.RequiredString);
var result = DataStringPropertyHelper.ValidateString(testDataModel, m => m.RequiredString);
Assert.AreEqual("", testDataModel.RequiredString);
Assert.AreEqual("TestDataModel.RequiredString", result.PropertyName);
Assert.True(result.SetRequiredToEmpty);
}
public void Truncates_string_as_expected()
{
var testDataModel = new TestDataModel
{
TruncateMe = "TRUNCATE ME!"
};
var result = DataStringPropertyHelper.ValidateString(testDataModel, m => m.TruncateMe);
Assert.AreEqual("TRUN", testDataModel.TruncateMe);
Assert.AreEqual("TestDataModel.TruncateMe", result.PropertyName);
Assert.AreEqual(4, result.TruncatedLength);
}
public void Does_nothing_to_undecorated_string_property()
{
const string str = "LEAVE ME ALONE!";
var testDataModel = new TestDataModel
{
LeaveMeAloneString = str
};
var result = DataStringPropertyHelper.ValidateString(testDataModel, m => m.LeaveMeAloneString);
Assert.AreEqual(str, testDataModel.LeaveMeAloneString);
Assert.Null(result);
}
public void Test10()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.CAR.AddObject(new CAR { CAR_ID = 1 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 1, DOOR_ID = 10 });
var finalDoors =
(from door in dataModel.DOOR
where (from door1 in dataModel.DOOR
select new { DoorId = door1.DOOR_ID, Cars = (from car in dataModel.CAR
select new { CAR_ID = (int?)car.CAR_ID }).Union(new[] { new { CAR_ID = (int?)null } }).Where(car => car.CAR_ID == door1.CAR_ID) }).Any(d => d.Cars.Any(c => c.CAR_ID == door.CAR_ID))
select door).ToList();
Assert.AreEqual(1, finalDoors.Count);
}
public void WhenCouldNotMaterializeShouldThrow()
{
var dataModel = new TestDataModel {Settings = {IsSmart = true}};
dataModel.CAR.AddObject(new CAR{CAR_ID = 1});
var propertyType = typeof(DOOR).GetProperty(NameSelecter.GetMemberName<DOOR>(x => x.DOOR_ID)).PropertyType;
Assert.False(propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(Nullable<>));
var cars =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
select new { car.CAR_ID, door.DOOR_ID });
Assert.Throws<NullReferenceException>(() => cars.ToList()); //ORM couldn't materialize null to not-nullable door.DOOR_ID and throw an exception, so unit-test should throw too.
}
void ExecuteTwoLeftJoins(bool isSmart)
{
var dataModel = new TestDataModel {Settings = {IsSmart = isSmart}};
const int carId = 100;
dataModel.CAR.AddObject(new CAR{CAR_ID = carId});
dataModel.CAR.AddObject(new CAR{CAR_ID = carId + 1});
var cars =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on door.DOOR_ID equals doorHandle.DOOR_ID
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
select car).ToList();
Assert.AreEqual(2, cars.Count);
Assert.AreEqual(carId, cars.First().CAR_ID);
}
private void ExecuteGroupBy(bool isSmart)
{
var dataModel = new TestDataModel {Settings = {IsSmart = isSmart}};
dataModel.DOOR.AddObject(new DOOR {DOOR_ID = 1});
dataModel.DOOR.AddObject(new DOOR { DOOR_ID = 2 });
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE { DOOR_HANDLE_ID = 1, DOOR_ID = 1, COLOR = "YELLOW" });
var minIdDoors =
(from door in dataModel.DOOR
join doorHandle in dataModel.DOOR_HANDLE on door.DOOR_ID equals doorHandle.DOOR_ID into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
join doorHandle2 in dataModel.DOOR_HANDLE on doorHandle.DOOR_HANDLE_ID equals doorHandle2.DOOR_HANDLE_ID into joinedDoorHandle2 from doorHandle2 in joinedDoorHandle2.DefaultIfEmpty()
group new {doorHandle2, door} by doorHandle2.COLOR into groupedDoorHandle
select new {Id = groupedDoorHandle.Min(x => x.door.DOOR_ID), Color = groupedDoorHandle.Key }).ToList();
Assert.AreEqual(1, minIdDoors.First().Id);
Assert.AreEqual("YELLOW", minIdDoors.First().Color);
Assert.AreEqual(null, minIdDoors[1].Color);
}
public void ExecuteContains(bool isSmart)
{
var dataModel = new TestDataModel { Settings = { IsSmart = isSmart } };
new[]
{
new DOOR_HANDLE {DOOR_HANDLE_ID = 1, MATERIAL_ID = 1},
new DOOR_HANDLE {DOOR_HANDLE_ID = 2, MATERIAL_ID = 2},
new DOOR_HANDLE {DOOR_HANDLE_ID = 3}
}
.ForEach(dataModel.DOOR_HANDLE.AddObject);
var doorHandleIds = new List<int>{1,2};
var doorHandles =
(from doorHandle in dataModel.DOOR_HANDLE
where doorHandleIds.Contains(doorHandle.MATERIAL_ID.Value)
select doorHandle).ToList();
Assert.AreEqual(2, doorHandles.Count);
}
void ExecuteSelect(bool isSmart)
{
var dataModel = new TestDataModel { Settings = { IsSmart = isSmart } };
dataModel.CAR.AddObject(new CAR {CAR_ID = 1});
dataModel.CAR.AddObject(new CAR {CAR_ID = 2});
dataModel.DOOR.AddObject(new DOOR {CAR_ID = 1, DOOR_ID = 1});
dataModel.DOOR.AddObject(new DOOR {CAR_ID = 2, DOOR_ID = 2});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE{DOOR_ID = 1, DOOR_HANDLE_ID = 1, COLOR = "RED"});
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on new {door.DOOR_ID} equals new {doorHandle.DOOR_ID}
into joinedDoorHandle from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.COLOR != "RED" || doorHandle == null
select car).ToList();
Assert.AreEqual(1, carsWithoutRedHandle.Count);
Assert.AreEqual(2, carsWithoutRedHandle.First().CAR_ID);
}
public void Test2()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true }};
dataModel.CAR.AddObject(new CAR {CAR_ID = 1} );
dataModel.CAR.AddObject(new CAR {CAR_ID = 2} );
var cars =
(from car in dataModel.CAR
select new {car.CAR_ID, Container = new Container{Id = car.CAR_ID, Id2 = car.CAR_ID + 1, SubContainer = new Container{Id = 5, SubContainer = new Container()}}}
)
.Where(x => x.Container.Id2 != 3)
.ToList();
var carExtended = cars.Single();
Assert.AreEqual(1, carExtended.CAR_ID);
Assert.AreEqual(1, carExtended.Container.Id);
Assert.AreEqual(2, carExtended.Container.Id2);
Assert.AreEqual(5, carExtended.Container.SubContainer.Id);
}
public void Test3()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {DOOR_HANDLE_ID = 1, MATERIAL_ID = 1});
var doorHandleIds = new List<int> { 1, 2 };
var doorHandles =
(from doorHandle in dataModel.DOOR_HANDLE
where doorHandleIds.Select(x => x).Select(x => x).Any()
select doorHandle).ToList();
Assert.AreEqual(1, doorHandles.Count);
}
public void Test4()
{
var dataModel = new TestDataModel {Settings = {IsSmart = true}};
dataModel.CAR.Where(y => y.CAR_ID == dataModel.CAR.Select(x => x).Sum(x => x.CAR_ID)).ToList();
}
public void Test5()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.CAR.AddObject(new CAR { CAR_ID = 1 });
dataModel.CAR.AddObject(new CAR { CAR_ID = 2 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 1, DOOR_ID = 1 });
dataModel.DOOR.AddObject(new DOOR { CAR_ID = 2, DOOR_ID = 2 });
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE { DOOR_ID = 1, DOOR_HANDLE_ID = 1, COLOR = "RED" });
var carsWithoutRedHandle =
(from car in dataModel.CAR
join door in dataModel.DOOR on car.CAR_ID equals door.CAR_ID
into joinedDoor
from door in joinedDoor.DefaultIfEmpty()
join doorHandle in dataModel.DOOR_HANDLE on new { door.DOOR_ID } equals new { doorHandle.DOOR_ID }
into joinedDoorHandle
from doorHandle in joinedDoorHandle.DefaultIfEmpty()
where doorHandle.COLOR != "RED" || doorHandle == null
select new{car}).First();
Assert.AreEqual(2, carsWithoutRedHandle.car.CAR_ID);
}
public void Test7()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.CAR.AddObject(new CAR { CAR_ID = 1 });
dataModel.CAR.AddObject(new CAR { CAR_ID = 2 });
var ids =
(from car in dataModel.CAR
select new { Id = car.CAR_ID > 1 ? car.CAR_ID : -1 }
)
.ToList();
Assert.AreEqual(2, ids.Count);
Assert.AreEqual(-1, ids[0].Id);
Assert.AreEqual(2, ids[1].Id);
}
public void Test8()
{
var dataModel = new TestDataModel { Settings = { IsSmart = true } };
dataModel.DOOR.AddObject(new DOOR { DOOR_ID = 100 });
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE {MATERIAL_ID = 100});
dataModel.DOOR_HANDLE.AddObject(new DOOR_HANDLE());
var handles =
(from handle in dataModel.DOOR_HANDLE
select new {Id = handle.MATERIAL_ID.Value});
var doors =
from door in dataModel.DOOR
where handles.Any(handle => handle.Id == door.DOOR_ID)
select door;
Assert.AreEqual(1, doors.Count());
}
void ExecuteNullableSumFromEmptyTable(bool isSmart)
{
var dataModel = new TestDataModel { Settings = { IsSmart = isSmart } };
int? sum = dataModel.DOOR_HANDLE.Sum(x => x.MATERIAL_ID);
Assert.AreEqual(null, sum);
}
void ExecuteSumFromEmptyTable(bool isSmart)
{
var dataModel = new TestDataModel {Settings = {IsSmart = isSmart}};
int sum = dataModel.CAR.Sum(x => x.CAR_ID);
}
