Update programs to match new test framework

epi_judge_cpp/absent_value_array.cc

@@ -20,11 +20,12 @@ int FindMissingElementWrapper(const vector<int>& stream) {
   }
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"stream"};
-  generic_test_main(argc, argv, param_names, "absent_value_array.tsv",
-                    &FindMissingElementWrapper);
+  GenericTestMain(args, "absent_value_array.tsv", &FindMissingElementWrapper,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/adding_credits.cc

@@ -71,11 +71,12 @@ void ClientsCreditsInfoTester(const std::vector<Operation>& ops) {
   }
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"ops"};
-  generic_test_main(argc, argv, param_names, "adding_credits.tsv",
-                    &ClientsCreditsInfoTester);
+  GenericTestMain(args, "adding_credits.tsv", &ClientsCreditsInfoTester,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/advance_by_offsets.cc

@@ -7,11 +7,12 @@ bool CanReachEnd(const vector<int>& max_advance_steps) {
   return true;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"max_advance_steps"};
-  generic_test_main(argc, argv, param_names, "advance_by_offsets.tsv",
-                    &CanReachEnd);
+  GenericTestMain(args, "advance_by_offsets.tsv", &CanReachEnd,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/alternating_array.cc

@@ -44,11 +44,12 @@ void RearrangeWrapper(TestTimer& timer, vector<int> A) {
   CheckAnswer(A);
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"timer", "A"};
-  generic_test_main(argc, argv, param_names, "alternating_array.tsv",
-                    &RearrangeWrapper);
+  GenericTestMain(args, "alternating_array.tsv", &RearrangeWrapper,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/anagrams.cc

@@ -9,12 +9,13 @@ vector<vector<string>> FindAnagrams(const vector<string>& dictionary) {
   return {};
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"dictionary"};
-  generic_test_main(
-      argc, argv, param_names, "anagrams.tsv", &FindAnagrams,
-      &UnorderedComparator<std::vector<std::vector<std::string>>>);
+  GenericTestMain(args, "anagrams.tsv", &FindAnagrams,
+                  &UnorderedComparator<std::vector<std::vector<std::string>>>,
+                  param_names);
   return 0;
 }

epi_judge_cpp/apply_permutation.cc

@@ -12,11 +12,12 @@ vector<int> ApplyPermutationWrapper(vector<int> perm, vector<int> A) {
   return A;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"perm", "A"};
-  generic_test_main(argc, argv, param_names, "apply_permutation.tsv",
-                    &ApplyPermutationWrapper);
+  GenericTestMain(args, "apply_permutation.tsv", &ApplyPermutationWrapper,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/arbitrage.cc

@@ -7,11 +7,12 @@ bool IsArbitrageExist(vector<vector<double>> graph) {
   return true;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"graph"};
-  generic_test_main(argc, argv, param_names, "arbitrage.tsv",
-                    &IsArbitrageExist);
+  GenericTestMain(args, "arbitrage.tsv", &IsArbitrageExist, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/binomial_coefficients.cc

@@ -5,11 +5,13 @@ int ComputeBinomialCoefficient(int n, int k) {
   return 0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"n", "k"};
-  generic_test_main(argc, argv, param_names, "binomial_coefficients.tsv",
-                    &ComputeBinomialCoefficient);
+  GenericTestMain(args, "binomial_coefficients.tsv",
+                  &ComputeBinomialCoefficient, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/bonus.cc

@@ -7,10 +7,12 @@ int CalculateBonus(const vector<int>& productivity) {
   return 0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"productivity"};
-  generic_test_main(argc, argv, param_names, "bonus.tsv", &CalculateBonus);
+  GenericTestMain(args, "bonus.tsv", &CalculateBonus, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/bst_from_preorder.cc

@@ -11,11 +11,12 @@ unique_ptr<BstNode<int>> RebuildBSTFromPreorder(
   return nullptr;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"preorder_sequence"};
-  generic_test_main(argc, argv, param_names, "bst_from_preorder.tsv",
-                    &RebuildBSTFromPreorder);
+  GenericTestMain(args, "bst_from_preorder.tsv", &RebuildBSTFromPreorder,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/bst_from_sorted_array.cc

@@ -26,11 +26,13 @@ int BuildMinHeightBSTFromSortedArrayWrapper(TestTimer& timer,
   return BinaryTreeHeight(result);
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"timer", "A"};
-  generic_test_main(argc, argv, param_names, "bst_from_sorted_array.tsv",
-                    &BuildMinHeightBSTFromSortedArrayWrapper);
+  GenericTestMain(args, "bst_from_sorted_array.tsv",
+                  &BuildMinHeightBSTFromSortedArrayWrapper, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/bst_merge.cc

@@ -10,10 +10,12 @@ shared_ptr<BstNode<int>> MergeTwoBSTs(shared_ptr<BstNode<int>> A,
   return nullptr;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"A", "B"};
-  generic_test_main(argc, argv, param_names, "bst_merge.tsv", &MergeTwoBSTs);
+  GenericTestMain(args, "bst_merge.tsv", &MergeTwoBSTs, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/bst_to_sorted_list.cc

@@ -33,11 +33,12 @@ std::vector<int> BSTToDoublyLinkedListWrapper(
   return v;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"timer", "tree"};
-  generic_test_main(argc, argv, param_names, "bst_to_sorted_list.tsv",
-                    &BSTToDoublyLinkedListWrapper);
+  GenericTestMain(args, "bst_to_sorted_list.tsv", &BSTToDoublyLinkedListWrapper,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/buy_and_sell_stock.cc

@@ -7,11 +7,12 @@ double BuyAndSellStockOnce(const vector<double>& prices) {
   return 0.0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"prices"};
-  generic_test_main(argc, argv, param_names, "buy_and_sell_stock.tsv",
-                    &BuyAndSellStockOnce);
+  GenericTestMain(args, "buy_and_sell_stock.tsv", &BuyAndSellStockOnce,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/buy_and_sell_stock_k_times.cc

@@ -7,11 +7,12 @@ double BuyAndSellStockKTimes(const vector<double>& prices, int k) {
   return 0.0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"prices", "k"};
-  generic_test_main(argc, argv, param_names, "buy_and_sell_stock_k_times.tsv",
-                    &BuyAndSellStockKTimes);
+  GenericTestMain(args, "buy_and_sell_stock_k_times.tsv",
+                  &BuyAndSellStockKTimes, DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/buy_and_sell_stock_twice.cc

@@ -7,11 +7,12 @@ double BuyAndSellStockTwice(const vector<double>& prices) {
   return 0.0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"prices"};
-  generic_test_main(argc, argv, param_names, "buy_and_sell_stock_twice.tsv",
-                    &BuyAndSellStockTwice);
+  GenericTestMain(args, "buy_and_sell_stock_twice.tsv", &BuyAndSellStockTwice,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/calendar_rendering.cc

@@ -16,11 +16,12 @@ int FindMaxSimultaneousEvents(const vector<Event>& A) {
 template <>
 struct SerializationTraits<Event> : UserSerTraits<Event, int, int> {};
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"A"};
-  generic_test_main(argc, argv, param_names, "calendar_rendering.tsv",
-                    &FindMaxSimultaneousEvents);
+  GenericTestMain(args, "calendar_rendering.tsv", &FindMaxSimultaneousEvents,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/circular_queue.cc

@@ -81,11 +81,12 @@ void QueueTester(const std::vector<QueueOp>& ops) {
   }
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"ops"};
-  generic_test_main(argc, argv, param_names, "circular_queue.tsv",
-                    &QueueTester);
+  GenericTestMain(args, "circular_queue.tsv", &QueueTester, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/closest_int_same_weight.cc

@@ -5,11 +5,12 @@ unsigned long ClosestIntSameBitCount(unsigned long x) {
   return 0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"x"};
-  generic_test_main(argc, argv, param_names, "closest_int_same_weight.tsv",
-                    &ClosestIntSameBitCount);
+  GenericTestMain(args, "closest_int_same_weight.tsv", &ClosestIntSameBitCount,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/collatz_checker.cc

@@ -7,11 +7,12 @@ bool TestCollatzConjecture(int n) {
   return true;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"n"};
-  generic_test_main(argc, argv, param_names, "collatz_checker.tsv",
-                    &TestCollatzConjecture);
+  GenericTestMain(args, "collatz_checker.tsv", &TestCollatzConjecture,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/combinations.cc

@@ -7,11 +7,13 @@ vector<vector<int>> Combinations(int n, int k) {
   return {};
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"n", "k"};
-  generic_test_main(argc, argv, param_names, "combinations.tsv", &Combinations,
-                    &UnorderedComparator<std::vector<std::vector<int>>>);
+  GenericTestMain(args, "combinations.tsv", &Combinations,
+                  &UnorderedComparator<std::vector<std::vector<int>>>,
+                  param_names);
   return 0;
 }

epi_judge_cpp/convert_base.cc

@@ -7,10 +7,12 @@ string ConvertBase(const string& num_as_string, int b1, int b2) {
   return "";
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"num_as_string", "b1", "b2"};
-  generic_test_main(argc, argv, param_names, "convert_base.tsv", &ConvertBase);
+  GenericTestMain(args, "convert_base.tsv", &ConvertBase, DefaultComparator{},
+                  param_names);
   return 0;
 }

epi_judge_cpp/copy_posting_list.cc

@@ -92,11 +92,12 @@ void CopyPostingsListWrapper(TestTimer& timer,
   AssertListsEqual(head, copy);
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"timer", "l"};
-  generic_test_main(argc, argv, param_names, "copy_posting_list.tsv",
-                    &CopyPostingsListWrapper);
+  GenericTestMain(args, "copy_posting_list.tsv", &CopyPostingsListWrapper,
+                  DefaultComparator{}, param_names);
   return 0;
 }

epi_judge_cpp/count_bits.cc

@@ -4,10 +4,12 @@ short CountBits(unsigned int x) {
   return 0;
 }
 
-#include "test_framework/test_utils_generic_main.h"
+#include "test_framework/generic_test.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"x"};
-  generic_test_main(argc, argv, param_names, "count_bits.tsv", &CountBits);
+  GenericTestMain(args, "count_bits.tsv", &CountBits, DefaultComparator{},
+                  param_names);
   return 0;
 }