Esempio n. 1
0
        public void CompareToStudentMethod(InstructorTestDto instructorTestDto,
                                           JavaTestMethod instructorTestMethod,
                                           JavaTestMethod studentTestMethod)
        {
            if (Covered(instructorTestMethod, studentTestMethod))
            {
                TestStatusEnum status;
                switch (instructorTestDto.StudentTests.Count)
                {
                case 0:
                    status = TestStatusEnum.Uncovered;
                    break;

                case 1:
                    status = TestStatusEnum.Covered;
                    break;

                default:
                {
                    status = TestStatusEnum.Redundant;
                    break;
                }
                }
                instructorTestDto.StudentTests.Add(new StudentTestDto
                {
                    Name       = studentTestMethod.Name,
                    Passed     = studentTestMethod.Passed,
                    TestStatus = status
                });
            }
        }
Esempio n. 2
0
        public InstructorTestDto GetInstructorTestDto(JavaTestMethod referenceTestMethod, List <JavaTestClass> studentTests)
        {
            var instructorTestDto = new InstructorTestDto
            {
                Name             = referenceTestMethod.Name,
                EquivalenceClass = referenceTestMethod.EquivalenceClass,
                Concepts         = referenceTestMethod.LearningConcepts,
                Passed           = referenceTestMethod.Passed,
            };

            foreach (var studentTestClass in studentTests)
            {
                foreach (var studentMethod in studentTestClass.Methods)
                {
                    if (studentMethod.LearningConcepts == null)
                    {
                        CompareToStudentMethod(instructorTestDto, referenceTestMethod, studentMethod);
                    }
                }
            }

            MarkInstructorDto(instructorTestDto);

            return(instructorTestDto);
        }
Esempio n. 3
0
        public void RunTestMethod(JavaTestClass javaTestClass, JavaTestMethod javaTestMethod,
                                  string originalCodeDirectory,
                                  string traceDirectory, string referenceCode = null)
        {
            var packageClassAndMethod = $"{javaTestClass.Package}.{javaTestClass.Name}#{javaTestMethod.Name}";
            var commandOptions        = GetCommandOptions(packageClassAndMethod, originalCodeDirectory, javaTestClass.ClassPath, javaTestClass.Name, javaTestMethod.Name, traceDirectory, referenceCode);

            var process = new EngineProcess(Command, commandOptions, originalCodeDirectory);

            try
            {
                var exitCode = process.Run();
                javaTestMethod.Passed = exitCode == 0;
            }
            catch (Exception e)
            {
                var exception = new EngineExceptionDto()
                {
                    Report = JavaEngineReportExceptionFactory
                             .GenerateReportForJunitTestRunnerTestMethodProcess(process, e, javaTestClass, javaTestMethod)
                };
                process.Stop();
                throw exception;
            }
            process.Stop();
        }
Esempio n. 4
0
 public static string GenerateReportForAnalysisLineCoverage(JavaTestMethod reference, JavaTestMethod student)
 {
     return("Failure to Trace Analysis.\n" +
            "Line number counts between reference and student are not the same.\n" +
            $"Method Name: {reference.Name}." +
            $"Reference Line Coverage Count: {reference.LineCoverages.Count}." +
            $"Student Line Coverage Count: {student.LineCoverages.Count}.");
 }
Esempio n. 5
0
        public static string GenerateReportForTraceJavaMethod(EngineProcess p, Exception e, JavaTestClass javaTestClass,
                                                              JavaTestMethod javaTestMethod)
        {
            var name       = GetNameFromJavaMethod(javaTestClass, javaTestMethod);
            var traceError = GetErrorFromProcess(p);

            return("Failure to run trace on java testMethod.\n" +
                   $"Name of Java Method: {name}\n" +
                   $"{GetMessageFromException(e)}\n" +
                   $"Trace Error:\n{traceError}");
        }
Esempio n. 6
0
 public void AddLineCoveragesFromReport(Report report, JavaTestMethod testMethod)
 {
     foreach (var sourceFile in GetTestFiles(report))
     {
         foreach (var line in sourceFile.Lines)
         {
             testMethod.AddLineCoverage(new LineCoverage
             {
                 LineNumber          = line.LineNumber,
                 CoveredBranches     = line.CoveredBranches,
                 MissedBranches      = line.MissedBranches,
                 CoveredInstructions = line.CoveredInstructions,
                 MissedInstructions  = line.MissingInstructions
             });
         }
     }
 }
Esempio n. 7
0
     private static bool Covered(JavaTestMethod referenceTestMethod, JavaTestMethod studentTestMethod)
     {
         if (referenceTestMethod.LineCoverages.Count != studentTestMethod.LineCoverages.Count)
         {
             throw new EngineExceptionDto()
                   {
                       Report = JavaEngineReportExceptionFactory.GenerateReportForAnalysisLineCoverage(referenceTestMethod, studentTestMethod)
                   }
         }
         ;
         return(!referenceTestMethod.LineCoverages.Where((r, i) => !(r.CoveredInstructions > 0
             ? studentTestMethod.LineCoverages[i].CoveredInstructions > 0
             : studentTestMethod.LineCoverages[i].CoveredInstructions == 0)).Any());
         //return !referenceTestMethod.LineCoverages.Where((t, i) => t.CoveredBranches > studentTestMethod.LineCoverages[i].CoveredBranches
         //                                                      || t.CoveredInstructions > studentTestMethod.LineCoverages[i].CoveredInstructions
         //                                                      || t.MissedBranches < studentTestMethod.LineCoverages[i].MissedBranches
         //                                                      || t.MissedInstructions < studentTestMethod.LineCoverages[i].MissedInstructions).Any();
     }
 }
Esempio n. 8
0
        public void TraceJavaMethod(JavaTestClass javaTestClass, JavaTestMethod testMethod, string workingDirectory)
        {
            var commandOptions = GetCommandOptions(javaTestClass.Name, testMethod.Name, javaTestClass.ClassPath);
            var process        = new EngineProcess(Command, commandOptions, workingDirectory);

            try
            {
                process.Run();
            }
            catch (Exception e)
            {
                var exception = new EngineExceptionDto()
                {
                    Report = JavaEngineReportExceptionFactory
                             .GenerateReportForTraceJavaMethod(process, e, javaTestClass, testMethod)
                };
                process.Stop();
                throw exception;
            }
            process.Stop();
        }
Esempio n. 9
0
        public static string GenerateReportForJunitTestRunnerTestMethodProcess(EngineProcess p, Exception e,
                                                                               JavaTestClass javaTestClass, JavaTestMethod javaTestMethod)
        {
            var name           = GetNameFromJavaMethod(javaTestClass, javaTestMethod);
            var junitTestError = GetErrorFromProcess(p);

            return("Failure to junit test runner for test testMethod.\n" +
                   $"Name of Java Method: {name}\n" +
                   $"{GetMessageFromException(e)}\n" +
                   $"Junit Test Error:\n{junitTestError}");
        }
Esempio n. 10
0
 private static string GetNameFromJavaMethod(JavaTestClass javaTestClass, JavaTestMethod javaTestMethod)
 => $"{GetNameFromJavaClass(javaTestClass)}#{javaTestMethod}";
Esempio n. 11
0
        public Report GetReport(string traceDirectory, JavaTestClass javaTestClass, JavaTestMethod testMethod)
        {
            var fileUri = Path.Combine(traceDirectory, $"{javaTestClass.Name}-{testMethod.Name}.xml");

            return(GetReport(fileUri));
        }