public void CreateExpertTest()
{
var exercise = ExerciseFactory.Create(RankLevel.Expert, 2);
Assert.AreEqual(RankLevel.Expert, exercise.Rank);
Assert.AreEqual(2, exercise.QuestionNumber);
}
public void WhenWeCreateNextAnExerciseWithValidAnswerWeGetAValidNewExercise()
{
var cache = new ExerciseFactoryCache();
var factory = new ExerciseFactory(new MockRandomNumberGenerator(new int[]
{
9, -3,
2, 3
}), cache);
var initialExercise = factory.CreateInitialExercise();
var answer = new Answer()
{
AssociatedExercise = initialExercise,
EquationWithAnswer = "9 + -3 = 6",
};
var exercise = factory.CreateNextExercise(answer);
Assert.IsNotNull(exercise);
Assert.IsNotNull(exercise.QuestionToAsk);
Assert.AreEqual("2 + 3 = ?", exercise.QuestionToAsk.EquationWithoutAnswer);
Assert.AreEqual("2 + 3 = 5", factory.GetAnswer(exercise.QuestionToAsk));
// second question for current rank
Assert.AreEqual(2, exercise.QuestionToAsk.QuestionNumberWithinCurrentRank);
Assert.IsTrue(exercise.QuestionToAsk.TimeToAnswer > 0);
Assert.AreEqual(Rank.Beginner, exercise.QuestionToAsk.Rank);
Console.WriteLine(answer.Display());
// {"AssociatedExercise":{"QuestionToAsk":{"EquationWithoutAnswer":"9 + -3 = ?","Rank":0,"QuestionNumberWithinCurrentRank":1,"TimeToAnswer":30},"CurrentStatus":null},"EquationWithAnswer":"9 + -3 = 6"}
}
public void CreateIntermediateTest()
{
var exercise = ExerciseFactory.Create(RankLevel.Intermediate, 3);
Assert.AreEqual(RankLevel.Intermediate, exercise.Rank);
Assert.AreEqual(3, exercise.QuestionNumber);
}
public void CreateAdvancedTest()
{
var exercise = ExerciseFactory.Create(RankLevel.Advanced, 1);
Assert.AreEqual(RankLevel.Advanced, exercise.Rank);
Assert.AreEqual(1, exercise.QuestionNumber);
}
public void CreateBeginnerTest()
{
var exercise = ExerciseFactory.Create(RankLevel.Beginner, 1);
Assert.AreEqual(RankLevel.Beginner, exercise.Rank);
Assert.AreEqual(1, exercise.QuestionNumber);
}
public void CreateTalentedTest()
{
var exercise = ExerciseFactory.Create(RankLevel.Talented, 2);
Assert.AreEqual(RankLevel.Talented, exercise.Rank);
Assert.AreEqual(2, exercise.QuestionNumber);
}
public void CreateExercise_ReturnsNotFinishedExercise()
{
var fixture = new Fixture();
var words = fixture.CreateMany <Word>();
var userMock = new Mock <IUser>();
userMock.SetupGet(mock => mock.StudiedWords).Returns(new StudiedWord[0]);
var userRepositoryMock = new Mock <IUserRepository>();
userRepositoryMock
.Setup(mock => mock.Load(It.IsAny <Guid>()))
.Returns(userMock.Object);
var wordRepositoryMock = new Mock <IWordsRepository>();
wordRepositoryMock.Setup(mock => mock.LoadAll()).Returns(words);
var settings = new TranslationTrainerSettings(5, 3);
var factory = new ExerciseFactory(
userRepositoryMock.Object,
wordRepositoryMock.Object,
settings);
var exercise = factory.Create(Guid.NewGuid());
Assert.IsFalse(exercise.Status.IsFinished);
}
public void WhenWeCallCreateNextExerciseWithInvalidAnswerWeGetAInvalidNewExercise()
{
var cache = new ExerciseFactoryCache();
var factory = new ExerciseFactory(new MockRandomNumberGenerator(new int[]
{
9, -3,
2, 3
}), cache);
var initialExercise = factory.CreateInitialExercise();
var answer = new Answer()
{
AssociatedExercise = initialExercise,
EquationWithAnswer = "9 + -3 = 99",
};
var exercise = factory.CreateNextExercise(answer);
Assert.IsNotNull(exercise);
// we dont have a question
Assert.IsNull(exercise.QuestionToAsk);
// status is in error state
Assert.IsTrue(exercise.CurrentStatus.IsErrored);
Assert.IsFalse(exercise.CurrentStatus.IsCompleted);
// we have message
Assert.IsNotNull(exercise.CurrentStatus.Message);
}
public void WhenWeAskFinalQuestionAtExpertLevelThenExerciseHasTheStatusCompleted()
{
var cache = new ExerciseFactoryCache();
var factory = new ExerciseFactory(new MockRandomNumberGenerator(new int[]
{
9, -3
}), cache);
var lastExercise = factory.CreateInitialExercise();
lastExercise.QuestionToAsk.QuestionNumberWithinCurrentRank = 3;
lastExercise.QuestionToAsk.Rank = Rank.Expert;
var answer = new Answer()
{
AssociatedExercise = lastExercise,
EquationWithAnswer = "9 + -3 = 6",
};
var exercise = factory.CreateNextExercise(answer);
Assert.IsNotNull(exercise);
// status is in error state
Assert.IsTrue(exercise.CurrentStatus.IsCompleted);
// we have message
Assert.IsNotNull(exercise.CurrentStatus.Message);
}
public override async Task <ExerciseDto> Handle(Input request, CancellationToken cancellationToken)
{
Exercise exercise;
if (request.Id == Guid.Empty)
{
exercise = ExerciseFactory.Create(request.Type);
Context.Exercises.Add(exercise);
}
else
{
switch (request.Type)
{
case "fill":
exercise = await Context.Exercises.OfType <FillTheBlanksExercise>()
.Include(x => x.Sentences)
.SingleOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
break;
default: throw new Exception("Unrecognized exercise type");
}
}
Mapper.Map(request, exercise);
await Context.SaveChangesAsync(cancellationToken);
return(Mapper.Map <ExerciseDto>(exercise));
}
public static async Task Main()
{
try
{
await ExerciseFactory.ExerciseCreate("Curse_CSharpProgramming_FromNoviceToSpecialist.Exercises.Section9.Section9Exercise3").DoExercise();
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
}
public void WhenWeCreateInitialExerciseWeShouldGetAValidExercise()
{
var cache = new ExerciseFactoryCache();
var factory = new ExerciseFactory(new MockRandomNumberGenerator(new int[] { 1, 2 }), cache);
var exercise = factory.CreateInitialExercise();
Assert.IsNotNull(exercise);
Assert.IsNotNull(exercise.QuestionToAsk);
Assert.AreEqual("1 + 2 = ?", exercise.QuestionToAsk.EquationWithoutAnswer);
Assert.AreEqual("1 + 2 = 3", factory.GetAnswer(exercise.QuestionToAsk));
Assert.IsTrue(exercise.QuestionToAsk.TimeToAnswer > 0);
Assert.AreEqual(Rank.Beginner, exercise.QuestionToAsk.Rank);
}
public Exercise GetNextExercise(Exercise exercise)
{
if (exercise == null)
{
return(ExerciseFactory.Create(RankLevel.Beginner));
}
if (PromoteToNextLevel(exercise.QuestionNumber))
{
var currentRank = GetNextLevel(exercise.Rank);
return(ExerciseFactory.Create(currentRank));
}
return(ExerciseFactory.Create(exercise.Rank, exercise.QuestionNumber + 1));
}
static void Main(string[] args)
{
Console.WriteLine("Exercises!");
// My goal here
// I want to see all available exercises in the system
// I select one specific exercise and see the basic information about it (description, parameters, example, test action)
// Test action: executes the test with the provided parameters and returns the result
// exercise.Execute
var collection = new ServiceCollection();
collection.AddScoped <IExerciseRepository, ExerciseRepository>();
collection.AddScoped <IExerciseManager, ExerciseManager>();
collection.AddScoped <IParameter, ParameterValue>();
var serviceProvider = collection.BuildServiceProvider();
var manager = serviceProvider.GetService <IExerciseManager>();
var exercises = manager.GetAll();
foreach (var exercise in exercises)
{
Console.WriteLine(exercise.ToString());
}
var arrayIntSumExercise = exercises.ElementAt(0);
var exerciseInstance = ExerciseFactory.Create(arrayIntSumExercise.AssemblyName, arrayIntSumExercise.ParameterTypeEnum);
var param = ParamFactory.CreateParameter("1 2 9 10", ParameterTypeEnum.ArrayInt);
var expectedResult = new int[5] {
1, 2, 9, 1, 1
};
var result = exerciseInstance.Execute(param);
if (result == expectedResult)
{
Console.WriteLine("Test: Ok");
}
else
{
Console.WriteLine("Test: Failed");
}
// My goal in future
// I want to see all available exercises in the system
// I select one specific exercise and see the basic information about it (description, parameters, example, submit code, see results)
// Submit code action: system interprets the code (must have the same parameters), compiles and executes using unit tests (mock data)
// See results action: system show results of unit tests (when they finish)
Console.ReadLine();
}
static void ExecuteExerciseAsync(int exerciseCode)
{
IExercise Exercise;
Exercise = ExerciseFactory.Create(exerciseCode);
if (Exercise == null)
{
Console.WriteLine("Error 404! Exercise not found!");
}
else
{
Exercise.Execute();
Console.WriteLine("Exercise successfully executed!");
}
}
public ExerciseResult <T> ExecuteExercise <T>(string parameterValue, IExercise exercise)
{
// 1 - Instantiate the Exercise
var execution = ExerciseFactory.Create(exercise.AssemblyName, exercise.ParameterTypeEnum);
// 2 - Convert the provided parameter values to the respective parameter of the exercise
var parameterValueConverted = ParamFactory.CreateParameter(parameterValue, exercise.ParameterTypeEnum);
// 3 - Execute the exercise based on the parameter values
var result = execution.Execute(parameterValueConverted);
return(new ExerciseResult <T>()
{
Success = true,
ResultValue = (T)result
});
}
public Quiz(
string title,
ExerciseFactory factory,
Randomizer randomizer,
MapperConfiguration mapperConfig,
List <Idiom> idioms = null
)
{
this.QuizId = Guid.NewGuid();
this.Title = title;
this.Exercises = new List <Exercise>();
this.IdiomsCollection = new List <IdiomInCollection>();
this.exerciseFactory = factory;
this.randomizer = randomizer;
this.mapperConfig = mapperConfig;
if (idioms != null)
{
AddToIdiomsCollection(idioms);
AddAutoExercises(3, 5);
}
}
private async void AddExerciseToDatabase(int id)
{
Exercise exercise1 = ExerciseFactory.CreateExercise("Touwtje springen");
exercise1.Id = id;
exercise1.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Touw")
};
exercise1.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Spring 30 keer"),
ExerciseFactory.CreateExerciseStep(2, "Rust"),
ExerciseFactory.CreateExerciseStep(3, "Spring nog eens 30 keer")
};
exercise1.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.springen),
ExerciseFactory.CreateExerciseForm(MovementForm.balans)
};
await this.exerciseRepository.CreateAsync(exercise1);
}
public void WhenWeCallCreateNextExerciseWithMultipleTimesWithTheCorrectAnswerWeChangeRank()
{
var cache = new ExerciseFactoryCache();
var factory = new ExerciseFactory(new MockRandomNumberGenerator(new int[]
{
9, -3,
2, 3,
3, 3,
4, 4
}), cache);
var initialExercise = factory.CreateInitialExercise();
var secondExercise = factory.CreateNextExercise(new Answer()
{
AssociatedExercise = initialExercise,
EquationWithAnswer = "9 + -3 = 6",
});
var thirdExercise = factory.CreateNextExercise(new Answer()
{
AssociatedExercise = secondExercise,
EquationWithAnswer = "2 + 3 = 5",
});
var forthExercise = factory.CreateNextExercise(new Answer()
{
AssociatedExercise = thirdExercise,
EquationWithAnswer = "3 + 3 = 6",
});
// should be 4 + 4
Assert.IsNotNull(forthExercise);
Assert.AreEqual("4 + 4 = ?", forthExercise.QuestionToAsk.EquationWithoutAnswer);
Assert.AreEqual("4 + 4 = 8", factory.GetAnswer(forthExercise.QuestionToAsk));
Assert.AreEqual(Rank.Intermmediate, forthExercise.QuestionToAsk.Rank);
Assert.AreEqual(1, forthExercise.QuestionToAsk.QuestionNumberWithinCurrentRank);
}
public void UpdateExercise(int id, string name, int weight, int repetitions, string skillevel)
{
ExerciseFactory.CreateExerciseDAL().UpdateExercise(id, name, weight, repetitions, skillevel);
}
private async void FillDatabase(bool withNonRealExercises = true)
{
// create first exercise
Exercise exercise1 = ExerciseFactory.CreateExercise("Touwtje springen");
exercise1.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Touw")
};
exercise1.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Spring 30 keer"),
ExerciseFactory.CreateExerciseStep(2, "Rust"),
ExerciseFactory.CreateExerciseStep(3, "Spring nog eens 30 keer")
};
exercise1.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.springen),
ExerciseFactory.CreateExerciseForm(MovementForm.balans)
};
await this.exerciseRepository.CreateAsync(exercise1);
// create second exercise
Exercise exercise2 = ExerciseFactory.CreateExercise("Voetballen");
exercise2.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Voetbal"),
ExerciseFactory.CreateExerciseRequirement("Voetbalschoenen")
};
exercise2.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Houd 40 keer hoog"),
ExerciseFactory.CreateExerciseStep(2, "Rust"),
ExerciseFactory.CreateExerciseStep(3, "Probeer je record te verbreken")
};
exercise2.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.mikken),
ExerciseFactory.CreateExerciseForm(MovementForm.balans)
};
await this.exerciseRepository.CreateAsync(exercise2);
// create third exercise
Exercise exercise3 = ExerciseFactory.CreateExercise("Ping pong");
exercise3.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Ping pong batjes"),
ExerciseFactory.CreateExerciseRequirement("Ping pong balletje")
};
exercise3.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Probeer de ping pong bal 20 keer hoog te houden"),
ExerciseFactory.CreateExerciseStep(2, "Probeer het nog eens"),
ExerciseFactory.CreateExerciseStep(3, "Ben je niet alleen? Probeer dan een 1 v 1")
};
exercise3.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.mikken)
};
await this.exerciseRepository.CreateAsync(exercise3);
if (withNonRealExercises)
{
// create exercise without requirements
Exercise exercise4 = ExerciseFactory.CreateExercise("Exercise zonder benodigdheden");
exercise4.ExerciseRequirements = new List <ExerciseRequirement>()
{
};
exercise4.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Step1")
};
exercise4.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.springen)
};
await this.exerciseRepository.CreateAsync(exercise4);
// create exercise without steps
Exercise exercise5 = ExerciseFactory.CreateExercise("Exercise zonder stappen");
exercise5.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Requirement1")
};
exercise5.ExerciseSteps = new List <ExerciseStep>()
{
};
exercise5.ExerciseForms = new List <ExerciseForm>()
{
ExerciseFactory.CreateExerciseForm(MovementForm.springen)
};
await this.exerciseRepository.CreateAsync(exercise5);
// create exercise without movement forms
Exercise exercise6 = ExerciseFactory.CreateExercise("Exercise zonder beweegvormen");
exercise6.ExerciseRequirements = new List <ExerciseRequirement>()
{
ExerciseFactory.CreateExerciseRequirement("Requirement1")
};
exercise6.ExerciseSteps = new List <ExerciseStep>()
{
ExerciseFactory.CreateExerciseStep(1, "Step1")
};
exercise6.ExerciseForms = new List <ExerciseForm>()
{
};
await this.exerciseRepository.CreateAsync(exercise6);
}
}
public Exercise GetFirstExercise()
{
return(ExerciseFactory.Create(RankLevel.Beginner));
}
