public void TwoErrors_Should_ThrowTwoExceptions()
        {
            var exception = Assert.Throws <ParserExceptionList>(() =>
                                                                CsvGradeCaseGenerator.ConvertTextToGradeCases(@"""test """" test2 """, @"""test """" test2 """));

            exception.Exceptions.Should().HaveCount(2);
        }
        public void ExceptionSyntax_Should_SetException(string input, string outputstr, bool isException, string msg)
        {
            var result = CsvGradeCaseGenerator.ConvertTextToGradeCases(input, outputstr);

            var output = result.Single().ExpectedOutputs.Single();

            output.Exception.Should().Be(isException);
            output.ValueToMatch.Should().Be(msg);
        }
        public async Task Exception_Should_Do(string input, string output, bool pass, string message, string sourceCode)
        {
            var cases = CsvGradeCaseGenerator.ConvertTextToGradeCases(input, output);

            var results = await consoleAppGrader.Grade(sourceCode, cases);

            var caseResult = results.CaseResults.Single();

            caseResult.Pass.Should().Be(pass);
            caseResult.ErrorMessage.Should().Be(message);
        }
        public async Task JsonConvertTest()
        {
            references.Add(typeof(JsonConvert).Assembly.Location);


            var cases = CsvGradeCaseGenerator.ConvertTextToGradeCases("", "");

            var results = await consoleAppGrader.Grade(SourceCodeStrings.JsonConvertSource, cases, references);

            var caseResult = results.CaseResults.Single();

            caseResult.Pass.Should().Be(true, caseResult.ErrorMessage);
        }
        public void MessageWithQuotations()
        {
            model.CsvExpectedOutput = @"""test""[this is a message],""test2[test]""";

            var result = CsvGradeCaseGenerator.ConvertTextToGradeCases(model.CsvCases, model.CsvExpectedOutput);

            var ot = result.First().ExpectedOutputs;

            ot[0].ValueToMatch.Should().Be("test");
            ot[0].Hint.Should().Be("this is a message");
            ot[1].ValueToMatch.Should().Be("test2[test]");
            ot[1].Hint.Should().BeNullOrEmpty();
        }
        public void NegateWithQuotations()
        {
            model.CsvExpectedOutput = @"!""test"",""!test2""";


            var result = CsvGradeCaseGenerator.ConvertTextToGradeCases(model.CsvCases, model.CsvExpectedOutput);

            var ot = result.First().ExpectedOutputs;

            ot[0].ValueToMatch.Should().Be("test");
            ot[0].Negate.Should().BeTrue();
            ot[1].ValueToMatch.Should().Be("!test2");
            ot[1].Negate.Should().BeFalse();
        }
        public void QuotationTest()
        {
            var CsvCases          = @"""test"", ""test2 "",""test,test"", test3 , , "" "" ,test[hint] ";
            var CsvExpectedOutput = "";

            var result = CsvGradeCaseGenerator.ConvertTextToGradeCases(CsvCases, CsvExpectedOutput);

            var inp = result.First().Inputs;

            inp[0].Should().Be("test");
            inp[1].Should().Be("test2 ");
            inp[2].Should().Be("test,test");
            inp[3].Should().Be(" test3 ");
            inp[4].Should().Be(" ");
            inp[5].Should().Be(" ");
        }
        public void ExpectedOutput_Should_Fail(string expected)
        {
            var result = Assert.Throws <ParserExceptionList>(() => CsvGradeCaseGenerator.ConvertTextToGradeCases("", expected));

            result.Exceptions.Should().HaveCount(1);
        }