submit -> grade

CMakeLists.txt

@@ -49,6 +49,16 @@ set(SOURCES
     include/tcframe/generator/GeneratorConfig.hpp
     include/tcframe/generator/GeneratorLogger.hpp
     include/tcframe/generator/TestCaseGenerator.hpp
+    include/tcframe/grader.hpp
+    include/tcframe/grader/BatchEvaluator.hpp
+    include/tcframe/grader/DiffScorer.hpp
+    include/tcframe/grader/Evaluator.hpp
+    include/tcframe/grader/Grader.hpp
+    include/tcframe/grader/GraderConfig.hpp
+    include/tcframe/grader/GraderLogger.hpp
+    include/tcframe/grader/Scorer.hpp
+    include/tcframe/grader/TestCaseGrader.hpp
+    include/tcframe/grader/Verdict.hpp
     include/tcframe/io_manipulator.hpp
     include/tcframe/io_manipulator/GridIOSegmentManipulator.hpp
     include/tcframe/io_manipulator/IOManipulator.hpp
@@ -107,16 +117,6 @@ set(SOURCES
     include/tcframe/spec/variable/Variable.hpp
     include/tcframe/spec/variable/Vector.hpp
     include/tcframe/spec/variable/WhitespaceManipulator.hpp
-    include/tcframe/submitter.hpp
-    include/tcframe/submitter/BatchEvaluator.hpp
-    include/tcframe/submitter/DiffScorer.hpp
-    include/tcframe/submitter/Evaluator.hpp
-    include/tcframe/submitter/Scorer.hpp
-    include/tcframe/submitter/Submitter.hpp
-    include/tcframe/submitter/SubmitterConfig.hpp
-    include/tcframe/submitter/SubmitterLogger.hpp
-    include/tcframe/submitter/TestCaseSubmitter.hpp
-    include/tcframe/submitter/Verdict.hpp
     include/tcframe/util.hpp
     include/tcframe/util/NotImplementedException.hpp
     include/tcframe/util/StringUtils.hpp
@@ -165,16 +165,16 @@ set(SOURCES
     test/tcframe/spec/variable/VariableTests.cpp
     test/tcframe/spec/variable/VectorTests.cpp
     test/tcframe/spec/variable/WhitespaceManipulatorTests.cpp
-    test/tcframe/submitter/BatchEvaluatorTests.cpp
-    test/tcframe/submitter/DiffScorerTests.cpp
-    test/tcframe/submitter/MockEvaluator.hpp
-    test/tcframe/submitter/MockScorer.hpp
-    test/tcframe/submitter/MockSubmitter.hpp
-    test/tcframe/submitter/MockSubmitterLogger.hpp
-    test/tcframe/submitter/MockTestCaseSubmitter.hpp
-    test/tcframe/submitter/SubmitterLoggerTests.cpp
-    test/tcframe/submitter/SubmitterTests.cpp
-    test/tcframe/submitter/TestCaseSubmitterTests.cpp
+    test/tcframe/grader/BatchEvaluatorTests.cpp
+    test/tcframe/grader/DiffScorerTests.cpp
+    test/tcframe/grader/GraderTests.cpp
+    test/tcframe/grader/GraderLoggerTests.cpp
+    test/tcframe/grader/MockEvaluator.hpp
+    test/tcframe/grader/MockScorer.hpp
+    test/tcframe/grader/MockGrader.hpp
+    test/tcframe/grader/MockGraderLogger.hpp
+    test/tcframe/grader/MockTestCaseGrader.hpp
+    test/tcframe/grader/TestCaseGraderTests.cpp
     test/tcframe/util/OptionalTests.cpp
     test/tcframe/util/StringUtilsTests.cpp
     test/tcframe/util/TestUtils.hpp
@@ -273,7 +273,7 @@ target_link_libraries(tests
 set(ETE_SOURCES
     ete-test/tcframe/BaseEteTests.cpp
     ete-test/tcframe/GenerationEteTests.cpp
-    ete-test/tcframe/SubmissionEteTests.cpp
+        ete-test/tcframe/GradingEteTests.cpp
 )
 
 add_executable(ete_tests ${ETE_SOURCES})

ete-test/resources/scripts/submit.sh → ete-test/resources/scripts/grade.sh

@@ -6,4 +6,4 @@ export TCFRAME_HOME=../../tcframe
 
 slug=$1
 g++ -o ${slug}_solution_alt ${slug}_solution_alt.cpp
-./${slug} submit --solution=./${slug}_solution_alt
+./${slug} grade --solution=./${slug}_solution_alt

ete-test/tcframe/SubmissionEteTests.cpp → ete-test/tcframe/GradingEteTests.cpp

@@ -8,10 +8,10 @@ using ::testing::Test;
 
 namespace tcframe {
 
-class SubmissionEteTests : public BaseEteTests {};
+class GradingEteTests : public BaseEteTests {};
 
-TEST_F(SubmissionEteTests, Normal) {
-    string result = exec("cd ete/normal && ../scripts/submit.sh normal");
+TEST_F(GradingEteTests, Normal) {
+    string result = exec("cd ete/normal && ../scripts/grade.sh normal");
     EXPECT_THAT(result, AllOf(
             HasSubstr("normal_sample_1: Accepted"),
             HasSubstr("normal_1: Wrong Answer"),

include/tcframe/grader.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "tcframe/grader/BatchEvaluator.hpp"
+#include "tcframe/grader/DiffScorer.hpp"
+#include "tcframe/grader/Evaluator.hpp"
+#include "tcframe/grader/Grader.hpp"
+#include "tcframe/grader/GraderConfig.hpp"
+#include "tcframe/grader/GraderLogger.hpp"
+#include "tcframe/grader/Scorer.hpp"
+#include "tcframe/grader/TestCaseGrader.hpp"
+#include "tcframe/grader/Verdict.hpp"

include/tcframe/submitter/BatchEvaluator.hpp → include/tcframe/grader/BatchEvaluator.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Evaluator.hpp"
-#include "SubmitterConfig.hpp"
-#include "SubmitterLogger.hpp"
+#include "GraderConfig.hpp"
+#include "GraderLogger.hpp"
 #include "Verdict.hpp"
 #include "tcframe/os.hpp"
 #include "tcframe/util.hpp"
@@ -12,14 +12,14 @@ namespace tcframe {
 class BatchEvaluator : public Evaluator {
 private:
     OperatingSystem* os_;
-    SubmitterLogger* logger_;
+    GraderLogger* logger_;
 
 public:
-    BatchEvaluator(OperatingSystem* os, SubmitterLogger* logger)
+    BatchEvaluator(OperatingSystem* os, GraderLogger* logger)
             : os_(os)
             , logger_(logger) {}
 
-    optional<Verdict> evaluate(const TestCase& testCase, const SubmitterConfig& config) {
+    optional<Verdict> evaluate(const TestCase& testCase, const GraderConfig& config) {
         string inputFilename = config.testCasesDir() + "/" + testCase.id() + ".in";
 
         ExecutionRequestBuilder request = ExecutionRequestBuilder()

include/tcframe/submitter/DiffScorer.hpp → include/tcframe/grader/DiffScorer.hpp

@@ -5,7 +5,7 @@
 
 #include "Scorer.hpp"
 #include "Verdict.hpp"
-#include "SubmitterLogger.hpp"
+#include "GraderLogger.hpp"
 #include "tcframe/os.hpp"
 
 using std::istreambuf_iterator;
@@ -16,14 +16,14 @@ namespace tcframe {
 class DiffScorer : public Scorer {
 private:
     OperatingSystem* os_;
-    SubmitterLogger* logger_;
+    GraderLogger* logger_;
 
 public:
-    DiffScorer(OperatingSystem* os, SubmitterLogger* logger)
+    DiffScorer(OperatingSystem* os, GraderLogger* logger)
             : os_(os)
             , logger_(logger) {}
 
-    Verdict score(const TestCase& testCase, const SubmitterConfig& config) {
+    Verdict score(const TestCase& testCase, const GraderConfig& config) {
         string outputFilename = config.testCasesDir() + "/" + testCase.id() + ".out";
 
         string briefDiffCommand = "diff --brief _evaluation.out " + outputFilename;

include/tcframe/submitter/Evaluator.hpp → include/tcframe/grader/Evaluator.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "SubmitterConfig.hpp"
+#include "GraderConfig.hpp"
 #include "Verdict.hpp"
 #include "tcframe/util.hpp"
 
@@ -10,7 +10,7 @@ class Evaluator {
 public:
     virtual ~Evaluator() {}
 
-    virtual optional<Verdict> evaluate(const TestCase& testCase, const SubmitterConfig& config) = 0;
+    virtual optional<Verdict> evaluate(const TestCase& testCase, const GraderConfig& config) = 0;
 };
 
 }

include/tcframe/submitter/Submitter.hpp → include/tcframe/grader/Grader.hpp

@@ -6,9 +6,9 @@
 #include <string>
 #include <vector>
 
-#include "SubmitterConfig.hpp"
-#include "SubmitterLogger.hpp"
-#include "TestCaseSubmitter.hpp"
+#include "GraderConfig.hpp"
+#include "GraderLogger.hpp"
+#include "TestCaseGrader.hpp"
 #include "Verdict.hpp"
 #include "tcframe/os.hpp"
 #include "tcframe/util.hpp"
@@ -21,19 +21,19 @@ using std::vector;
 
 namespace tcframe {
 
-class Submitter {
+class Grader {
 private:
-    TestCaseSubmitter* testCaseSubmitter_;
-    SubmitterLogger* logger_;
+    TestCaseGrader* testCaseGrader_;
+    GraderLogger* logger_;
 
 public:
-    virtual ~Submitter() {}
+    virtual ~Grader() {}
 
-    Submitter(TestCaseSubmitter* testCaseSubmitter, SubmitterLogger* logger)
-            : testCaseSubmitter_(testCaseSubmitter)
+    Grader(TestCaseGrader* testCaseGrader, GraderLogger* logger)
+            : testCaseGrader_(testCaseGrader)
             , logger_(logger) {}
 
-    virtual void submit(const TestSuite& testSuite, const set<int>& subtaskIds, const SubmitterConfig& config) {
+    virtual void grade(const TestSuite& testSuite, const set<int>& subtaskIds, const GraderConfig& config) {
         logger_->logIntroduction();
 
         map<int, Verdict> subtaskVerdicts;
@@ -42,16 +42,16 @@ class Submitter {
         }
 
         for (const TestGroup& testGroup : testSuite.testGroups()) {
-            submitOnTestGroup(testGroup, config, subtaskVerdicts);
+            gradeOnTestGroup(testGroup, config, subtaskVerdicts);
         }
 
         logger_->logResult(subtaskVerdicts);
     }
 
 private:
-    void submitOnTestGroup(
+    void gradeOnTestGroup(
             const TestGroup& testGroup,
-            const SubmitterConfig& config,
+            const GraderConfig& config,
             map<int, Verdict>& subtaskVerdicts) {
 
         logger_->logTestGroupIntroduction(testGroup.id());
@@ -61,26 +61,26 @@ class Submitter {
                     .setId(TestCaseIdCreator::createBaseId(config.slug(), testGroup.id()))
                     .setSubtaskIds(testGroup.testCases()[0].subtaskIds())
                     .build();
-            submitOnTestCase(testCase, config, subtaskVerdicts);
+            gradeOnTestCase(testCase, config, subtaskVerdicts);
         } else {
             for (const TestCase& testCase : testGroup.testCases()) {
-                submitOnTestCase(testCase, config, subtaskVerdicts);
+                gradeOnTestCase(testCase, config, subtaskVerdicts);
             }
         }
     }
 
-    void submitOnTestCase(const TestCase& testCase, const SubmitterConfig& config, map<int, Verdict>& subtaskVerdicts) {
-        Verdict verdict = testCaseSubmitter_->submit(testCase, config);
+    void gradeOnTestCase(const TestCase& testCase, const GraderConfig& config, map<int, Verdict>& subtaskVerdicts) {
+        Verdict verdict = testCaseGrader_->grade(testCase, config);
         for (int subtaskId : testCase.subtaskIds()) {
             subtaskVerdicts[subtaskId] = max(subtaskVerdicts[subtaskId], verdict);
         }
     }
 };
 
-class SubmitterFactory {
+class GraderFactory {
 public:
-    virtual Submitter* create(TestCaseSubmitter* testCaseSubmitter, SubmitterLogger* logger) {
-        return new Submitter(testCaseSubmitter, logger);
+    virtual Grader* create(TestCaseGrader* testCaseGrader, GraderLogger* logger) {
+        return new Grader(testCaseGrader, logger);
     }
 };
 

include/tcframe/submitter/SubmitterConfig.hpp → include/tcframe/grader/GraderConfig.hpp

@@ -11,8 +11,8 @@ using std::string;
 
 namespace tcframe {
 
-class SubmitterConfig {
-    friend class SubmitterConfigBuilder;
+class GraderConfig {
+    friend class GraderConfigBuilder;
 
 private:
     string slug_;
@@ -48,75 +48,75 @@ class SubmitterConfig {
         return memoryLimit_;
     }
 
-    bool operator==(const SubmitterConfig& o) const {
+    bool operator==(const GraderConfig& o) const {
         return tie(hasMultipleTestCases_, slug_, solutionCommand_, outputDir_, timeLimit_, memoryLimit_) ==
                 tie(o.hasMultipleTestCases_,o.slug_, o.solutionCommand_, o.outputDir_, o.timeLimit_,
                     o.memoryLimit_);
     }
 };
 
-class SubmitterConfigBuilder {
+class GraderConfigBuilder {
 private:
-    SubmitterConfig subject_;
+    GraderConfig subject_;
 
 public:
-    SubmitterConfigBuilder(const SubmitterConfig& from)
+    GraderConfigBuilder(const GraderConfig& from)
             : subject_(from) {}
 
-    SubmitterConfigBuilder(string slug) {
+    GraderConfigBuilder(string slug) {
         subject_.slug_ = slug;
         subject_.hasMultipleTestCases_ = false;
         subject_.solutionCommand_ = CommonConfig::solutionCommand();
         subject_.outputDir_ = CommonConfig::outputDir();
     }
 
-    SubmitterConfigBuilder& setHasMultipleTestCases(optional<bool> hasMultipleTestCases) {
+    GraderConfigBuilder& setHasMultipleTestCases(optional<bool> hasMultipleTestCases) {
         if (hasMultipleTestCases) {
             setHasMultipleTestCases(hasMultipleTestCases.value());
         }
         return *this;
     }
 
-    SubmitterConfigBuilder& setHasMultipleTestCases(bool hasMultipleTestCases) {
+    GraderConfigBuilder& setHasMultipleTestCases(bool hasMultipleTestCases) {
         subject_.hasMultipleTestCases_ = hasMultipleTestCases;
         return *this;
     }
 
-    SubmitterConfigBuilder& setSolutionCommand(optional<string> solutionCommand) {
+    GraderConfigBuilder& setSolutionCommand(optional<string> solutionCommand) {
         if (solutionCommand) {
             setSolutionCommand(solutionCommand.value());
         }
         return *this;
     }
 
-    SubmitterConfigBuilder& setSolutionCommand(string solutionCommand) {
+    GraderConfigBuilder& setSolutionCommand(string solutionCommand) {
         subject_.solutionCommand_ = solutionCommand;
         return *this;
     }
 
-    SubmitterConfigBuilder& setOutputDir(optional<string> outputDir) {
+    GraderConfigBuilder& setOutputDir(optional<string> outputDir) {
         if (outputDir) {
             setOutputDir(outputDir.value());
         }
         return *this;
     }
 
-    SubmitterConfigBuilder& setOutputDir(string outputDir) {
+    GraderConfigBuilder& setOutputDir(string outputDir) {
         subject_.outputDir_ = outputDir;
         return *this;
     }
 
-    SubmitterConfigBuilder& setTimeLimit(int timeLimit) {
+    GraderConfigBuilder& setTimeLimit(int timeLimit) {
         subject_.timeLimit_ = optional<int>(timeLimit);
         return *this;
     }
 
-    SubmitterConfigBuilder& setMemoryLimit(int memoryLimit) {
+    GraderConfigBuilder& setMemoryLimit(int memoryLimit) {
         subject_.memoryLimit_ = optional<int>(memoryLimit);
         return *this;
     }
 
-    SubmitterConfig build() {
+    GraderConfig build() {
         return move(subject_);
     }
 };

include/tcframe/submitter/SubmitterLogger.hpp → include/tcframe/grader/GraderLogger.hpp

@@ -10,15 +10,15 @@ using std::map;
 
 namespace tcframe {
 
-class SubmitterLogger : public BaseLogger {
+class GraderLogger : public BaseLogger {
 public:
-    virtual ~SubmitterLogger() {}
+    virtual ~GraderLogger() {}
 
-    SubmitterLogger(LoggerEngine* engine)
+    GraderLogger(LoggerEngine* engine)
             : BaseLogger(engine) {}
 
     virtual void logIntroduction() {
-        engine_->logParagraph(0, "Submitting...");
+        engine_->logParagraph(0, "Grading...");
     }
 
     virtual void logTestCaseVerdict(const Verdict& verdict) {