static void Main(string[] args)
{
SequenceController sequenceController = new SequenceController(args[0]);
sequenceController.DisplaySequence();
Console.ReadKey();
}
public void PopulateRing(float ringDistance)
{
ringSize = ringDistance;
sequenceController = GetComponentInParent <SequenceController>();
circleScripts = new CircleScript[beats.Count];
for (int i = 0; i < beats.Count; i++)
{
//Instantiate the circle
GameObject newCircle = Instantiate(circlePrefab);
CircleScript circleScript = newCircle.GetComponent <CircleScript>();
//Initialize the Circle
circleScript.Initialize(ringKeycode, beats[i], ringAudio, audioMixerGroup);
newCircle.transform.SetParent(this.transform);
circleScript.ringParent = this;
//locate the Circle based on it's beat
//Debug.Log("Locating Circle " + i.ToString());
circleScript.LocateCircle(ringDistance);
//Give it a measure
circleScript.measure = GiveMeasure(beats[i]);
if (isMelody)
{
circleScript.SetClip(melodyNotes[i]);
}
circleScripts[i] = circleScript;
}
}
private void CanDoThreeStepsAndTwoBackAnd1forward_CheckStep2b(SequenceController sequenceController)
{
//we are getting 1 parameters in the question
Assert.Single(sequenceController.LastExecutionResult.Questions.Parameters);
//check that the prarmeters have the right name and type
Assert.Equal("toetsingsinkomen_aanvrager", sequenceController.LastExecutionResult.Questions.Parameters[0].Name);
Assert.Equal(TypeInference.InferenceResult.TypeEnum.Double, sequenceController.LastExecutionResult.Questions.Parameters[0].Type);
//3 parameters known as a response after requesting step 1
Assert.Equal(3, sequenceController.LastExecutionResult.Parameters.Count);
//check that the parameters have the right name and type & value
var var1 = sequenceController.LastExecutionResult.Parameters.FirstOrDefault(p => p.Name == "alleenstaande");
Assert.NotNull(var1);
Assert.Equal(TypeInference.InferenceResult.TypeEnum.Boolean, var1.Type);
Assert.False((bool)var1.Value);
var var2 = sequenceController.LastExecutionResult.Parameters.FirstOrDefault(p => p.Name == "aanvrager_met_toeslagpartner");
Assert.NotNull(var2);
Assert.Equal(TypeInference.InferenceResult.TypeEnum.Boolean, var2.Type);
Assert.True((bool)var2.Value);
var var3 = sequenceController.LastExecutionResult.Parameters.FirstOrDefault(p => p.Name == "standaardpremie");
Assert.NotNull(var3);
Assert.Equal(TypeInference.InferenceResult.TypeEnum.Double, var3.Type);
Assert.Equal(3218, (double)var3.Value);
//we should be at step 2
Assert.Equal(2, sequenceController.CurrentStep);
//this step should have key 1
Assert.Equal(2, sequenceController.LastExecutionResult.Stacktrace.Count);
Assert.Equal(1, sequenceController.LastExecutionResult.Stacktrace.Last().Step.Key);
//the sequence should have 2 steps
Assert.Equal(2, sequenceController.Sequence.Steps.Count());
//and the last step should be key 1
Assert.Equal(1, sequenceController.Sequence.Steps.Last().Key);
}
private void GetPreviousStep()
{
//decrease the request step, can never be lower than 1
SequenceController.DecreaseStep();
ProcessStep();
StateHasChanged();
}
private void ShouldNotGetSavedValueNoExecutionResult()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
var result = sut.GetSavedValue();
Assert.Null(result);
}
public void ShouldInit()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
Assert.Equal(0, sut.CurrentStep);
Assert.Equal(0, sut.RequestStep);
}
public void ShouldGetGetParseResult()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
var result = sut.GetParseResult();
moqServiceController.Verify(m => m.Parse(It.IsAny <IParseRequest>()), Times.Once());
}
public void ShouldGetGetParseRequest()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
var result = sut.GetParseRequest();
Assert.Equal("YamlFileUrl", result.Config);
}
private TurtleGame GetTurtleGame(IResultReporter resultReporter)
{
var gameSettings = new GameSettingsBuilder().Build();
IBoardController boardController = new BoardController(gameSettings);
ISequencesRetriever sequencesRetriever = new InMemorySequenceRetriever();
ISequenceController sequenceController = new SequenceController(sequencesRetriever);
return(new TurtleGame(boardController, sequenceController, resultReporter));
}
private void GetNextStep()
{
if (FormIsValid())
{
//increase the requ6est step
SequenceController.IncreaseStep();
ProcessStep();
}
StateHasChanged();
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.File("log.txt")
.CreateLogger();
SequenceController sequenceController = new SequenceController();
sequenceController.Run();
}
private void ShouldNotGetSavedValueNoStepMatch()
{
var moqServiceController = InitMoqServiceController(true);
var moqSequence = InitMoqSequence(true);
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
sut.ExecuteStep(It.IsAny <IParametersCollection>());
var result = sut.GetSavedValue();
Assert.Null(result);
}
public void ShouldDecreraseAndIncreaseSteps()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
sut.DecreaseStep();
Assert.Equal(1, sut.RequestStep);//decrease but ca't be lower than 1
sut.IncreaseStep();
Assert.Equal(2, sut.RequestStep);
}
public void OrderSequenceTest_DescendingOrder_ReturnDescendingOrder()
{
//Arrange
var controller = new SequenceController();
//Act
var result = controller.OrderSequence("5 4 6 2 1", Directions.Descending);
//Assert
Assert.AreEqual("6 5 4 2 1", result.Item2);
}
public void GetConditionalSequence_3_And_5()
{
// Arrange
SequenceController controller = new SequenceController();
// Act
var result = controller.GetConditionalSequence(15);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("Z", result);
}
public void RunReturnsOKStatus()
{
// Arrange
var sequenceController = new SequenceController(_sequenceModelBuilderMock.Object);
// Act
var result = sequenceController.Run("test string");
// Assert
Assert.IsInstanceOf <OkResult>(result);
}
public void RunCallsSequenceRunMethod()
{
// Arrange
var sequenceController = new SequenceController(_sequenceModelBuilderMock.Object);
// Act
sequenceController.Run("test string");
// Assert
_sequenceMock.Verify(x => x.Run(), Times.Once());
}
public void TestDeleteSequence()
{
using (TransactionScope scope = new TransactionScope())
{
int id = SaveItem(PopulateNewItem());
if (id != -1)
{
Sequence sequenceToDelete = new Sequence();
sequenceToDelete.Id = id;
Assert.IsTrue(SequenceController.DeleteSequence(sequenceToDelete));
}
}
}
private void ProcessStep()
{
SequenceController.ExecuteStep(GetCurrentParameters());
var unresolvedParameters = ContentController.GetUnresolvedParameters(SemanticKey, SequenceController.LastExecutionResult.Parameters);
var parameters = SequenceController.LastExecutionResult.Parameters;
if (unresolvedParameters != null && unresolvedParameters.Any())
{
SequenceController.FillUnresolvedParameters(ref parameters, unresolvedParameters);
}
ContentController.Parameters = parameters;
Display();
}
public void LoadSequence_GivenMoves_ReturnSequence()
{
var moves = new char[] { 'a' };
Mock <ISequencesRetriever> mockSequencesRetriever = new Mock <ISequencesRetriever>();
mockSequencesRetriever.Setup(m => m.GetNextSequenceOfMoves()).Returns(moves);
ISequencesRetriever sequencesRetriever = mockSequencesRetriever.Object;
var sut = new SequenceController(sequencesRetriever);
var result = sut.LoadSequence();
Assert.IsType <Sequence>(result);
}
public void GetOddSequence()
{
// Arrange
SequenceController controller = new SequenceController();
// Act
IEnumerable <int> result = controller.GetOddSequence(10);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(5, result.Count());
Assert.AreEqual(5, result.ElementAt(2));
Assert.AreEqual(9, result.ElementAt(4));
}
public void LoadSequence_GivenEmptyMoves_ReturnNull()
{
char[] moves = Array.Empty <char>();
Mock <ISequencesRetriever> mockSequencesRetriever = new Mock <ISequencesRetriever>();
mockSequencesRetriever.Setup(m => m.GetNextSequenceOfMoves()).Returns(moves);
ISequencesRetriever sequencesRetriever = mockSequencesRetriever.Object;
var sut = new SequenceController(sequencesRetriever);
var result = sut.LoadSequence();
Assert.Null(result);
}
private void Display()
{
_formElement = new FormElementBase();
if (HasRights)
{
_formElement = _formElement.GetFormElement(SequenceController.LastExecutionResult);
_formElement.FillDataFromResult(SequenceController.LastExecutionResult, ContentController);
if (_formElement.ShowElement)
{
_formElement.Data.Value = SequenceController.GetSavedValue() ?? _formElement.Data.Value;
ValidateForm(true); //set the IsValid and ErrorText Property unobtrusive
}
}
}
public void ShouldGetExecuteRequest()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
var result = sut.GetExecuteRequest();
Assert.Equal("YamlFileUrl", result.Config);
Assert.Null(result.Parameters);
result = sut.GetExecuteRequest(GetDummyParameterCollection());
Assert.Single(result.Parameters.GetAll());
Assert.Equal("TestParam", result.Parameters.GetAll().ElementAt(0).Name);
}
public void CreateTest_EnterSequence_ReturnSequenceList()
{
//Arrange
var controller = new SequenceController(mockContext.Object);
//Act
var result = (RedirectToRouteResult)controller.Create(new Sequence
{
NewSequence = "2 1 3",
Direction = Directions.Ascending
});
//Assert
Assert.IsTrue(result.RouteValues["action"].Equals("SequenceList"));
}
private void ShouldGetSavedValueNumber()
{
var moqServiceController = InitMoqServiceController(true, TypeInference.InferenceResult.TypeEnum.Double);
var moqSequence = InitMoqSequence(true, true,
new List <IClientParameter> {
new ClientParameter("TheName", "1234.23", TypeInference.InferenceResult.TypeEnum.Double, "Dummy"),
});
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
sut.ExecuteStep(It.IsAny <IParametersCollection>());
var result = sut.GetSavedValue();
Assert.NotNull(result);
Assert.Equal("1234,23", result);
}
public void LoadSequence_GivenMoreMoves_ReturnSequenceIdIncremented()
{
var moves = new char[] { 'a' };
Mock <ISequencesRetriever> mockSequencesRetriever = new Mock <ISequencesRetriever>();
mockSequencesRetriever.Setup(m => m.GetNextSequenceOfMoves()).Returns(moves);
ISequencesRetriever sequencesRetriever = mockSequencesRetriever.Object;
var sut = new SequenceController(sequencesRetriever);
var firstResult = (Sequence)sut.LoadSequence();
var secondResult = (Sequence)sut.LoadSequence();
Assert.Equal(firstResult.SequenceId + 1, secondResult.SequenceId);
}
public void Initialize()
{
UserInput = 50;
// setup sequence generator
var sequenceGenerator = MockRepository.GenerateStub <ISequenceGenerator>();
sequenceGenerator.Stub(x => x.GetNumberSequence(UserInput)).Return(GenerateMockStubResponse <NumberSequence>());
sequenceGenerator.Stub(x => x.GetOddSequence(UserInput)).Return(GenerateMockStubResponse <OddSequence>());
sequenceGenerator.Stub(x => x.GetEvenSequence(UserInput)).Return(GenerateMockStubResponse <EvenSequence>());
sequenceGenerator.Stub(x => x.GetSpeicalSequence(UserInput)).Return(GenerateMockStubResponse <SpecialSequence>());
sequenceGenerator.Stub(x => x.GetFibonacciSequence(UserInput)).Return(GenerateMockStubResponse <FibonacciSequence>());
Controller = new SequenceController(sequenceGenerator);
}
private void ShouldGetSavedValueBoolean()
{
var moqServiceController = InitMoqServiceController(true, TypeInference.InferenceResult.TypeEnum.Boolean);
var moqSequence = InitMoqSequence(true, true,
new List <IClientParameter> {
new ClientParameter("Name1", true, TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy"),
new ClientParameter("Name2", false, TypeInference.InferenceResult.TypeEnum.Boolean, "Dummy")
});
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
sut.ExecuteStep(It.IsAny <IParametersCollection>());
var result = sut.GetSavedValue();
Assert.NotNull(result);
Assert.Equal("Name1", result);
}
public void ShouldExecuteStep()
{
var moqServiceController = InitMoqServiceController();
var moqSequence = InitMoqSequence();
var sut = new SequenceController(moqServiceController.Object, moqSequence.Object);
var moqParametersCollection = It.IsAny <IParametersCollection>();
sut.IncreaseStep();
sut.ExecuteStep(moqParametersCollection);
moqSequence.Verify(m => m.GetParametersToSend(1), Times.Once());
moqSequence.Verify(m => m.UpdateParametersCollection(It.IsAny <IParametersCollection>()), Times.Once());
moqSequence.Verify(m => m.AddStep(1, It.IsAny <IExecutionResult>()), Times.Once());
moqSequence.Verify(m => m.UpdateParametersCollection(It.IsAny <IParametersCollection>()), Times.Once());
Assert.Equal(1, sut.CurrentStep);
}
