public void CalculationGet()
{
// Arrange
var results = new List <CalculationResult> {
{ new CalculationResult {
OperationName = "Add", Result = "1", num1 = 0, num2 = 1
} },
{ new CalculationResult {
OperationName = "Multiply", Result = "2", num1 = 1, num2 = 2
} },
{ new CalculationResult {
OperationName = "Compare", Result = "0", num1 = 1, num2 = 1
} }
};
var mock = new Mock <IRepository>();
mock.SetupGet(m => m.Results).Returns(results);
var controller = new CalculationController(mock.Object);
// Act
var model = controller.Get();
// Assert
Assert.Equal(results, model);
}
public async Task PostOverflowTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repo => repo.Get(1))
.Returns(() => Task.FromResult(Mock.Of <ICalculation>(c => c.Id == 1 && c.Current == 1)));
var calculatorMock = new Mock <ICalculator>();
calculatorMock.Setup(c => c.Calculate(It.IsAny <int>(), It.IsAny <int>())).Throws <InvalidOperationException>();
var responseMock = new Mock <IResponseSender>();
responseMock.Setup(r => r.SendResponseAsync(It.IsAny <ICalculation>()));
var controller = new CalculationController(repoMock.Object,
calculatorMock.Object, responseMock.Object);
var result = await controller.CalculateNext(1, 1);
Assert.IsInstanceOfType(result, typeof(StatusCodeResult));
var statusCodeResult = result as StatusCodeResult;
Assert.AreEqual(HttpStatusCode.ResetContent, statusCodeResult.StatusCode);
repoMock.Verify(r => r.Get(1), Times.Once);
repoMock.Verify(r => r.Update(It.Is <ICalculation>(c => c.Id == 1 && c.Current == 2)), Times.Never);
calculatorMock.Verify(c => c.Calculate(1, 1), Times.Once);
responseMock.Verify(r => r.SendResponseAsync(It.IsAny <ICalculation>()), Times.Never);
}
public async Task PostNextTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repo => repo.Get(1))
.Returns(() => Task.FromResult(Mock.Of <ICalculation>(c => c.Id == 1 && c.Current == 1)));
repoMock.Setup(r => r.Update(It.IsAny <ICalculation>())).Returns(Task.CompletedTask);
var calculatorMock = new Mock <ICalculator>();
calculatorMock.Setup(c => c.Calculate(1, 1)).Returns(2);
var responseMock = new Mock <IResponseSender>();
responseMock.Setup(r => r.SendResponseAsync(It.IsAny <ICalculation>())).Returns(Task.CompletedTask);
var controller = new CalculationController(repoMock.Object,
calculatorMock.Object, responseMock.Object);
var result = await controller.CalculateNext(1, 1);
Assert.IsInstanceOfType(result, typeof(OkResult));
repoMock.Verify(r => r.Get(1), Times.Once);
repoMock.Verify(r => r.Update(It.Is <ICalculation>(c => c.Id == 1 && c.Current == 2)), Times.Once);
calculatorMock.Verify(c => c.Calculate(1, 1), Times.Once);
responseMock.Verify(r => r.SendResponseAsync(It.Is <ICalculation>(c => c.Id == 1 && c.Current == 2)));
}
public CalculationControllerUTests()
{
_calculationManager = new Mock <ICalculationManager>();
_logger = new Mock <ILogger <CalculationController> >();
_calculationController = new CalculationController(_logger.Object, _calculationManager.Object);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!this.Page.IsPostBack)
{
bool IsCom = false;
int ret = 0;
if (!string.IsNullOrEmpty(Request.Form["ctl00$MainContent$heUserID"]) && !string.IsNullOrEmpty(Request.Form["ctl00$MainContent$hdTsID"]))
{
//try
//{
int UserId = int.Parse(Request.Form["ctl00$MainContent$heUserID"]);
int tsid = int.Parse(Request.Form["ctl00$MainContent$hdTsID"]);
//Profile Process
//Model_ReportItemResult cr = new Model_ReportItemResult();
Model_UsersAssessment cr = new Model_UsersAssessment();
string resultID = Request.Form["ass_fill_ch_"];
if (!string.IsNullOrEmpty(resultID))
{
string[] arrResultID = resultID.Split(',');
foreach (string r in arrResultID)
{
int intTASID = int.Parse(r);
int RankVal = int.Parse(Request.Form["ass_fill_ch_sc_" + r]);
IsCom = cr.UpdateUserRank(intTASID, RankVal);
}
}
if (IsCom)
{
ret = CalculationController.CalculateActionStart(tsid);
}
}
string strRet = "True";
switch (ret)
{
case -1:
strRet = "False";
break;
case 0:
strRet = "True";
break;
default:
strRet = ret.ToString();
break;
}
Response.Write(strRet);
Response.End();
}
}
public void Init()
{
_overallCar = new OverallCar();
_overallCar.Wheelbase = 1.5f;
_overallCar.Weight = 200;
_overallCar.TrackWidth = 1.5f;
_overallCar.Drag = new Spline(new[] { 0d, 100d }, new[] { 0d, 0d });
OverallCarOutput.LastCalculation.Direction = new Vector3(1, 0, 0);
OverallCarOutput.LastCalculation.Speed = 10;
OverallCarOutput.LastCalculation.Position = new Vector3();
WheelOutput.LastCalculations[0] = new WheelOutput();
WheelOutput.LastCalculations[0].Direction = new Vector2(1, 1).Normalize();
WheelOutput.LastCalculations[0].LateralAcceleration = 100;
WheelOutput.LastCalculations[0].LongitudinalAccelerationForce = 0;
WheelOutput.LastCalculations[0].LongitudinalDecelerationForce = 10;
WheelOutput.LastCalculations[0] = new WheelOutput();
WheelOutput.LastCalculations[0].Direction = new Vector2(1, 1).Normalize();
WheelOutput.LastCalculations[0].LateralAcceleration = 100;
WheelOutput.LastCalculations[0].LongitudinalAccelerationForce = 0;
WheelOutput.LastCalculations[0].LongitudinalDecelerationForce = 10;
WheelOutput.LastCalculations[0] = new WheelOutput();
WheelOutput.LastCalculations[0].Direction = new Vector2(1, 0).Normalize();
WheelOutput.LastCalculations[0].LateralAcceleration = 0;
WheelOutput.LastCalculations[0].LongitudinalAccelerationForce = 50;
WheelOutput.LastCalculations[0].LongitudinalDecelerationForce = 10;
WheelOutput.LastCalculations[0] = new WheelOutput();
WheelOutput.LastCalculations[0].Direction = new Vector2(1, 0).Normalize();
WheelOutput.LastCalculations[0].LateralAcceleration = 0;
WheelOutput.LastCalculations[0].LongitudinalAccelerationForce = 50;
WheelOutput.LastCalculations[0].LongitudinalDecelerationForce = 10;
CalculationController.Initialize(1);
}
//called periodically
private void FixedUpdate()
{
// Get Input Data
lock (InputData.ActualInputData)
{
InputData.ActualInputData = new InputData(Input.GetAxis("AccelerationPedal"),
Input.GetAxis("BrakePedal"), Input.GetAxis("Steering"), InputData.ActualInputData.Gear);
}
if (!RaceMenu.ShowMenu)
{
CalculationController.Calculate();
}
}
public async Task CompleteNotFoundTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repository => repository.Remove(1)).Returns(Task.FromResult(false));
var controller = new CalculationController(repoMock.Object,
Mock.Of <ICalculator>(), Mock.Of <IResponseSender>());
var result = await controller.CompleteCalculation(1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
repoMock.Verify(r => r.Remove(1), Times.Once);
}
public async Task CompleteExceptionTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repository => repository.Remove(1)).Throws <Exception>();
var controller = new CalculationController(repoMock.Object,
Mock.Of <ICalculator>(), Mock.Of <IResponseSender>());
var result = await controller.CompleteCalculation(1);
Assert.IsInstanceOfType(result, typeof(ExceptionResult));
repoMock.Verify(r => r.Remove(1), Times.Once);
}
public async Task CreateNewExceptionTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repository => repository.CreateNew()).Throws <InvalidOperationException>();
var controller = new CalculationController(repoMock.Object,
Mock.Of <ICalculator>(), Mock.Of <IResponseSender>());
var result = await controller.CreateNewCalculation();
Assert.IsInstanceOfType(result, typeof(ExceptionResult));
repoMock.Verify(r => r.CreateNew(), Times.Once);
}
public async Task CallsCalculatorPool_With_ReceivedRequest()
{
var pool = new Mock <ICalculatorPool>();
var sut = new CalculationController(pool.Object);
var request = CalculationRequest.Initial;
await sut.Calculate(request.CorrelationId, request.Value.ToString());
pool.Verify(
x =>
x.Receive(
It.Is <CalculationRequest>(
r => r.CorrelationId == request.CorrelationId && r.Value == request.Value)));
}
protected void btnRecal_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(Request.QueryString["ts"]))
{
int tsID = int.Parse(Request.QueryString["ts"]);
int IsCom = CalculationController.CalculateActionStart(tsID);
if (IsCom == 0)
{
Response.Redirect(Request.Url.ToString());
}
}
Response.Redirect(Request.Url.ToString());
}
public async Task CreateNewTest()
{
var repoMock = new Mock <ICalculationRepository>();
repoMock.Setup(repository => repository.CreateNew())
.Returns(Task.FromResult(Mock.Of <ICalculation>(c => c.Id == 1 && c.Current == 0)));
var controller = new CalculationController(repoMock.Object,
Mock.Of <ICalculator>(), Mock.Of <IResponseSender>());
var result = await controller.CreateNewCalculation();
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <int>));
var ok = result as OkNegotiatedContentResult <int>;
Assert.AreEqual(1, ok.Content);
repoMock.Verify(r => r.CreateNew(), Times.Once);
}
public void Can_Get_Stored_TaxCalculations()
{
A.CallTo(() => _taxCalculationQueryProvider.Query).WithAnyArguments().Returns(CalculationTestData.TaxCalculations);
_calculationController = new CalculationController(_taxCalculationQueryProvider, _calculationComm);
var results = _calculationController.Get();
Assert.IsTrue(results.Value.Count() > 0);//There is or are postal codes...
foreach (var calculation in results.Value)
{
Assert.IsTrue(calculation.Income > 0); //there should always be a positive number as an income
Assert.IsTrue(calculation.Id > 0); //the id should always be available on each record for a Delete or Updates?
Assert.IsTrue(calculation.PostalCode != ""); //There should alwasy be a postal code, no empty string is expected by the Client
}
}
public void Initialize()
{
_mockCalcClient = new Mock <ICalculationsApiClient>();
_mockMapper = new Mock <IMapper>();
_mockAuthorizationHelper = new Mock <IAuthorizationHelper>();
_mockResultsApiClient = new Mock <IResultsApiClient>();
Calculation calculation = Builder <Calculation> .CreateNew().Build();
_mockCalcClient.Setup(x => x.GetCalculationById("ABC123")).ReturnsAsync(
new ApiResponse <Calculation>(HttpStatusCode.OK, Builder <Calculation> .CreateNew().Build()));
_mockCalcClient.Setup(x => x.GetCalculationById("FooBar")).ReturnsAsync(
new ApiResponse <Calculation>(HttpStatusCode.BadRequest, null));
_sut = new CalculationController(_mockCalcClient.Object, _mockMapper.Object, _mockAuthorizationHelper.Object, _mockResultsApiClient.Object);
}
Race SetupARaceFromFiles(int raceIndex)
{
MainFormCollection FormCollection = new MainFormCollection();
FormCollection.AddForm(StratSim.Program.StartProject());
StratSim.Program.InfoPanel = new InfoPanel(FormCollection[0]);
CalculationController.PopulateDriverDataFromFiles(raceIndex);
CalculationController.CalculatePaceParameters();
CalculationController.OptimiseAllStrategies(raceIndex);
CalculationController.SetRaceStrategies();
RaceStrategy[] strategies = new RaceStrategy[Data.NumberOfDrivers];
for (int driverIndex = 0; driverIndex < Data.NumberOfDrivers; driverIndex++)
{
strategies[driverIndex] = Data.Drivers[driverIndex].RaceStrategy;
}
return(new Race(raceIndex, strategies, FormCollection[0]));
}
public void TestCalculationController()
{
InputData.ActualInputData = new InputData(0, 1, 0, 1);
CalculationController.Initialize(1);
CalculationController.Calculate();
Thread.Sleep(100); //wait until the calculation should be ready
Assert.AreNotEqual(BrakeOutput.LastCalculation.BrakeMomentFront, 0); //due to the calculate the value dshould have changed
float oldValue = BrakeOutput.LastCalculation.BrakeMomentFront;
InputData.ActualInputData = new InputData(1, 0, 0, 2);
CalculationController.Interrupt();
CalculationController.Calculate();
Thread.Sleep(100); //wait until the calculation should be ready
Assert.AreEqual(oldValue, BrakeOutput.LastCalculation.BrakeMomentFront); //the value should not have change because the calculation was interrupted
CalculationController.Initialize(1); //Continue the Calculation
CalculationController.Calculate();
Thread.Sleep(100); //wait until the calculation should be ready
Assert.AreEqual(0, BrakeOutput.LastCalculation.BrakeMomentFront);
CalculationController.Terminate();
}
public void Init()
{
_wheels = new Wheels();
SuspensionOutput sout0 = new SuspensionOutput();
sout0.AccelerationTorque = 0;
sout0.WheelAngle = (float)Math.PI / 4;
sout0.WheelLoad = 50 * 9.81f;
SuspensionOutput sout1 = new SuspensionOutput();
sout1.AccelerationTorque = 0;
sout1.WheelAngle = (float)Math.PI / 5;
sout1.WheelLoad = 50 * 9.81f;
SuspensionOutput sout2 = new SuspensionOutput();
sout2.AccelerationTorque = 50;
sout2.WheelAngle = 0;
sout2.WheelLoad = 50 * 9.81f;
SuspensionOutput sout3 = new SuspensionOutput();
sout3.AccelerationTorque = 50;
sout3.WheelAngle = 0;
sout3.WheelLoad = 50 * 9.81f;
SuspensionOutput.LastCalculations[0] = sout0;
SuspensionOutput.LastCalculations[1] = sout1;
SuspensionOutput.LastCalculations[2] = sout2;
SuspensionOutput.LastCalculations[3] = sout3;
SteeringOutput.LastCalculation.RadiusFrontAxis = 10;
SteeringOutput.LastCalculation.RadiusRearAxis = 10;
CalculationController.Instance.Wheels.Diameter = 0.5f;
CalculationController.Instance.OverallCar.TrackWidth = 1.5f;
CalculationController.Initialize(1);
BrakeOutput.LastCalculation.BrakeMomentFront = 10;
BrakeOutput.LastCalculation.BrakeMomentRear = 10;
OverallCarOutput.LastCalculation.Speed = 10;
OverallCarOutput.LastCalculation.Direction = new Vector3(1, 0, 0);
}
public async Task Should_GetCalculationsForSpecification_InvalidId_ReturnError()
{
_mockCalcClient.Setup(x =>
x.SearchCalculationsForSpecification(
"FooBar",
It.IsAny <CalculationType>(),
null,
It.IsAny <string>(),
It.IsAny <int>()))
.ReturnsAsync(
new ApiResponse <SearchResults <CalculationSearchResult> >(
HttpStatusCode.BadRequest,
Builder <SearchResults <CalculationSearchResult> >
.CreateNew()
.Build()));
_sut = new CalculationController(_mockCalcClient.Object, _mockMapper.Object, _mockAuthorizationHelper.Object, _mockResultsApiClient.Object);
var actual = await _sut.GetCalculationsForSpecification("FooBar", CalculationType.Template, 1, null, "");
actual.Should().BeOfType <BadRequestObjectResult>();
}
// Initialization
private void Start()
{
CalculationController.Initialize(Time.fixedDeltaTime);
InputData.ActualInputData = new InputData(0, 0, 0, 0);
}
private void OnDestroy()
{
CalculationController.Interrupt();
}
//quitting
private void OnApplicationQuit()
{
CalculationController.Terminate();
}
public CalculationNumbersTest()
{
controller = new CalculationController(_ilogger.Object);//Step 4
}
public void CalculationControllerConstructorTest()
{
CalculationController target = new CalculationController();
Assert.IsNotNull(target);
}
public CalculationControllerTest()
{
this._controller = new CalculationController();
}
protected void Page_Load(object sender, EventArgs e)
{
if (!this.Page.IsPostBack)
{
bool IsCom = false;
int ret = 0;
if (!string.IsNullOrEmpty(Request.Form["ctl00$MainContent$heUserID"]))
{
//try
//{
int UserId = int.Parse(Request.Form["ctl00$MainContent$heUserID"]);
//Profile Process
string FirstName = Request.Form["ctl00$MainContent$firstName"];
string LastName = Request.Form["ctl00$MainContent$LastName"];
string bytGender = Request.Form["ctl00$MainContent$dropGender"];
string Nationality = Request.Form["ctl00$MainContent$dropNation"];
string DatBirth = Request.Form["ctl00$MainContent$day"];
string Phone = Request.Form["ctl00$MainContent$txtPhon"];
Model_Users us = new Model_Users
{
UserID = UserId,
FirstName = FirstName,
LastName = LastName,
DateofBirth = DatBirth.DateSplitYear('-'),
Gender = byte.Parse(bytGender),
Nationality = int.Parse(Nationality),
MobileNumber = Phone
};
us.UpdateUserProfileFront(us);
//Fuction Competencies
string FCCheck = Request.Form["chckFC_form"];
if (!string.IsNullOrEmpty(FCCheck))
{
string[] arrfc = FCCheck.Split(',');
if (arrfc.Length > 0)
{
List <Model_UserFC> list = new List <Model_UserFC>();
foreach (string i in arrfc)
{
list.Add(new Model_UserFC
{
FCID = int.Parse(i),
UserID = UserId
});
}
Model_UserFC fc = new Model_UserFC();
fc.AddUserFC(list, UserId);
}
}
//Current Job
string CJFCheck = Request.Form["chckCJF_form"];
if (!string.IsNullOrEmpty(CJFCheck))
{
string[] arrcjf = CJFCheck.Split(',');
if (arrcjf.Length > 0)
{
List <Model_UserCJF> list = new List <Model_UserCJF>();
foreach (string i in arrcjf)
{
list.Add(new Model_UserCJF
{
CJFID = int.Parse(i),
UserID = UserId
});
}
Model_UserCJF cjf = new Model_UserCJF();
cjf.AddUserCjf(list, UserId);
}
}
//UserAssessment Transaction
Model_UsersTransaction ts = new Model_UsersTransaction
{
UserID = UserId
};
int tsid = ts.InsertUserTsAss(ts);
if (tsid > 0)
{
//Score Process
string ass = Request.Form["ass_fill_"];
if (!string.IsNullOrEmpty(Request.Form["ass_fill_"]))
{
string[] arrAss = ass.Split(',');
if (arrAss.Length > 0)
{
//List<Model_UsersAssessment> uslist = new List<Model_UsersAssessment>();
foreach (string assItem in arrAss)
{
string assSCore = Request.Form["ass_fill_i_sc_" + assItem];
//if (!string.IsNullOrEmpty(assSCore))
// {
int AssID = int.Parse(assItem);
int AssScore = 0;
if (!string.IsNullOrEmpty(assSCore))
{
AssScore = int.Parse(assSCore);
}
Model_UsersAssessment uass = new Model_UsersAssessment
{
ASID = AssID,
TransactionID = tsid,
Score = AssScore
};
int intTASID = uass.InsertUserAssessment(uass);
string asssChoice = Request.Form["ass_fill_ch_" + assItem];
if (!string.IsNullOrEmpty(asssChoice))
{
string[] arrChoice = asssChoice.Split(',');
if (arrChoice.Length > 0)
{
foreach (string choiceItem in arrChoice)
{
string assChoiceScore = Request.Form["ass_fill_ch_sc_" + assItem + "_" + choiceItem];
if (!string.IsNullOrEmpty(assChoiceScore))
{
int AssChoiceID = int.Parse(choiceItem);
int AssChoiceScore = int.Parse(assChoiceScore);
Model_UsersAssChoice usch = new Model_UsersAssChoice
{
ASID = AssID,
TransactionID = tsid,
ASCID = AssChoiceID,
TASID = intTASID,
Score = AssChoiceScore
};
usch.InsertUserAssessmentChoice(usch);
//insert choice here
}
}
}
}
// }
}
}
}
}
// assessment is recorded!
IsCom = true;
if (IsCom)
{
ret = CalculationController.CalculateActionStart(tsid);
}
//}
//catch(Exception ex)
//{
// string ee = ex.Message + ex.StackTrace;
// IsCom = false;
//}
}
string strRet = "True";
switch (ret)
{
case -1:
strRet = "False";
break;
case 0:
strRet = "True";
break;
default:
strRet = ret.ToString();
break;
}
Response.Write(strRet);
Response.End();
}
}
public void TestCalculationControllerTerminate()
{
CalculationController.Initialize(1);
CalculationController.Terminate();
CalculationController.Initialize(1); //an exception should be thrown because the workerThread was already started
}
