Put the logic of final aggregator to Grader itself

This logic doesn't require points because it's just summing up subtask points.
ia-toki · May 6, 2017 · 1284d76 · 1284d76
1 parent f3850d5
commit 1284d76
Show file tree

Hide file tree

Showing 6 changed files with 26 additions and 37 deletions.
diff --git a/include/tcframe/aggregator/MinAggregator.hpp b/include/tcframe/aggregator/MinAggregator.hpp
@@ -16,11 +16,11 @@ class MinAggregator : public Aggregator {
     virtual ~MinAggregator() {}
 
     Verdict aggregate(const vector<Verdict>& verdicts) {
-        Verdict aggregatedVerdict;
+        VerdictStatus aggregatedStatus = VerdictStatus::ac();
         for (const Verdict& verdict : verdicts) {
-            aggregatedVerdict = max(aggregatedVerdict, verdict);
+            aggregatedStatus = max(aggregatedStatus, verdict.status());
         }
-        return aggregatedVerdict;
+        return Verdict(aggregatedStatus);
     }
 };
 

diff --git a/include/tcframe/aggregator/SumAggregator.hpp b/include/tcframe/aggregator/SumAggregator.hpp
@@ -16,11 +16,11 @@ class SumAggregator : public Aggregator {
     virtual ~SumAggregator() {}
 
     Verdict aggregate(const vector<Verdict>& verdicts) {
-        Verdict aggregatedVerdict;
+        VerdictStatus aggregatedStatus = VerdictStatus::ac();
         for (const Verdict& verdict : verdicts) {
-            aggregatedVerdict = max(aggregatedVerdict, verdict);
+            aggregatedStatus = max(aggregatedStatus, verdict.status());
         }
-        return aggregatedVerdict;
+        return Verdict(aggregatedStatus);
     }
 };
 

diff --git a/include/tcframe/grader/Grader.hpp b/include/tcframe/grader/Grader.hpp
@@ -27,16 +27,14 @@ class Grader {
 private:
     TestCaseGrader* testCaseGrader_;
     Aggregator* aggregator_;
-    Aggregator* finalAggregator_;
     GraderLogger* logger_;
 
 public:
     virtual ~Grader() {}
 
-    Grader(TestCaseGrader* testCaseGrader, Aggregator* aggregator, Aggregator* finalAggregator, GraderLogger* logger)
+    Grader(TestCaseGrader* testCaseGrader, Aggregator* aggregator, GraderLogger* logger)
             : testCaseGrader_(testCaseGrader)
             , aggregator_(aggregator)
-            , finalAggregator_(finalAggregator)
             , logger_(logger) {}
 
     virtual void grade(const TestSuite& testSuite, const ConstraintSuite& constraintSuite, const GraderConfig& config) {
@@ -61,7 +59,7 @@ class Grader {
                 subtaskVerdicts.push_back(subtaskVerdict);
             }
         }
-        Verdict verdict = finalAggregator_->aggregate(subtaskVerdicts);
+        Verdict verdict = aggregate(subtaskVerdicts);
 
         logger_->logResult(subtaskVerdictsById, verdict);
     }
@@ -111,12 +109,20 @@ class Grader {
             verdictsBySubtaskId[subtaskId].push_back(verdict);
         }
     }
+
+    Verdict aggregate(const vector<Verdict>& subtaskVerdicts) {
+        VerdictStatus aggregatedStatus = VerdictStatus::ac();
+        for (const Verdict& verdict : subtaskVerdicts) {
+            aggregatedStatus = max(aggregatedStatus, verdict.status());
+        }
+        return Verdict(aggregatedStatus);
+    }
 };
 
 class GraderFactory {
 public:
     virtual Grader* create(TestCaseGrader* testCaseGrader, Aggregator* aggregator, GraderLogger* logger) {
-        return new Grader(testCaseGrader, aggregator, new SumAggregator(), logger);
+        return new Grader(testCaseGrader, aggregator, logger);
     }
 };
 

diff --git a/include/tcframe/verdict/Verdict.hpp b/include/tcframe/verdict/Verdict.hpp
@@ -33,10 +33,6 @@ struct Verdict {
     bool operator==(const Verdict& o) const {
         return tie(status_, points_) == tie(o.status_, o.points_);
     }
-
-    bool operator<(const Verdict& o) const {
-        return status_ < o.status_;
-    }
 };
 
 }
diff --git a/test/unit/tcframe/grader/GraderTests.cpp b/test/unit/tcframe/grader/GraderTests.cpp
@@ -23,7 +23,6 @@ class GraderTests : public Test {
 
     MOCK(TestCaseGrader) testCaseGrader;
     MOCK(Aggregator) aggregator;
-    MOCK(Aggregator) finalAggregator;
     MOCK(GraderLogger) logger;
 
     TestCase stcA = TestUtils::newSampleTestCase("foo_sample_1");
@@ -47,10 +46,10 @@ class GraderTests : public Test {
     Verdict tc2Verdict = Verdict(8);
     Verdict tc3Verdict = Verdict(9);
 
-    Verdict subtaskVerdict = Verdict(10);
-    Verdict subtask1Verdict = Verdict(11);
-    Verdict subtask2Verdict = Verdict(12);
-    Verdict verdict = Verdict(13);
+    Verdict mainSubtaskVerdict = Verdict(VerdictStatus::ac());
+    Verdict subtask1Verdict = Verdict(VerdictStatus::wa());
+    Verdict subtask2Verdict = Verdict(VerdictStatus::tle());
+    Verdict verdict = Verdict(VerdictStatus::tle());
 
     TestSuite testSuite = TestSuite({
             TestGroup(TestGroup::SAMPLE_ID, {stcA, stcB}),
@@ -79,7 +78,7 @@ class GraderTests : public Test {
             .setHasMultipleTestCases(true)
             .build();
 
-    Grader grader = Grader(&testCaseGrader, &aggregator, &finalAggregator, &logger);
+    Grader grader = Grader(&testCaseGrader, &aggregator, &logger);
 
     void SetUp() {
         ON_CALL(testCaseGrader, grade(stcA, _)).WillByDefault(Return(stcAVerdict));
@@ -108,14 +107,11 @@ TEST_F(GraderTests, Grading) {
         EXPECT_CALL(testCaseGrader, grade(tcB, config));
 
         EXPECT_CALL(aggregator, aggregate(vector<Verdict>{tcAVerdict, tcBVerdict}))
-                .WillOnce(Return(subtaskVerdict));
-
-        EXPECT_CALL(finalAggregator, aggregate(vector<Verdict>{subtaskVerdict}))
-                .WillOnce(Return(verdict));
+                .WillOnce(Return(mainSubtaskVerdict));
 
         EXPECT_CALL(logger, logResult(
-                map<int, Verdict>{{Subtask::MAIN_ID, subtaskVerdict}},
-                verdict));
+                map<int, Verdict>{{Subtask::MAIN_ID, mainSubtaskVerdict}},
+                mainSubtaskVerdict));
     }
     grader.grade(testSuite, constraintSuite, config);
 }
@@ -139,9 +135,6 @@ TEST_F(GraderTests, Grading_WithSubtasks) {
                 vector<Verdict>{stc1Verdict, stc2Verdict, tc1Verdict, tc2Verdict, tc3Verdict}))
                 .WillOnce(Return(subtask2Verdict));
 
-        EXPECT_CALL(finalAggregator, aggregate(vector<Verdict>{subtask1Verdict, subtask2Verdict}))
-                .WillOnce(Return(verdict));
-
         EXPECT_CALL(logger, logResult(
                 map<int, Verdict>{{1, subtask1Verdict}, {2, subtask2Verdict}},
                 verdict));
@@ -158,9 +151,6 @@ TEST_F(GraderTests, Grading_WithSubtasks_WithGlobalConstraints) {
                 vector<Verdict>{stc1Verdict, stc2Verdict, tc1Verdict, tc2Verdict, tc3Verdict}))
                 .WillOnce(Return(subtask2Verdict));
 
-        EXPECT_CALL(finalAggregator, aggregate(vector<Verdict>{subtask1Verdict, subtask2Verdict}))
-                .WillOnce(Return(verdict));
-
         EXPECT_CALL(logger, logResult(
                 map<int, Verdict>{{1, subtask1Verdict}, {2, subtask2Verdict}},
                 verdict));
@@ -188,9 +178,6 @@ TEST_F(GraderTests, Grading_WithSubtasks_MultipleTestCases) {
                 vector<Verdict>{stc1Verdict, tc1Verdict, tc2Verdict}))
                 .WillOnce(Return(subtask2Verdict));
 
-        EXPECT_CALL(finalAggregator, aggregate(vector<Verdict>{subtask1Verdict, subtask2Verdict}))
-                .WillOnce(Return(verdict));
-
         EXPECT_CALL(logger, logResult(
                 map<int, Verdict>{{1, subtask1Verdict}, {2, subtask2Verdict}},
                 verdict));

diff --git a/test/unit/tcframe/grader/MockGrader.hpp b/test/unit/tcframe/grader/MockGrader.hpp
@@ -9,7 +9,7 @@ namespace tcframe {
 class MockGrader : public Grader {
 public:
     MockGrader()
-            : Grader(nullptr, nullptr, nullptr, nullptr) {}
+            : Grader(nullptr, nullptr, nullptr) {}
 
     MOCK_METHOD3(grade, void(const TestSuite&, const ConstraintSuite&, const GraderConfig&));
 };