Move tests to legacy_ prepend

Author: baylesj

src/jsontestrunner/main.cpp

@@ -17,6 +17,7 @@
 #include <cstdio>
 #include <json/json.h>
 #include <memory>
+#include <iostream>
 #include <sstream>
 
 struct Options {
@@ -143,7 +144,8 @@ static int parseAndSaveValueTree(const Json::String& input,
         reader->parse(input.data(), input.data() + input.size(), root, &errors);
 
     if (!parsingSuccessful) {
-      printf("Failed to parse %s file: \n%s\n", kind.c_str(), errors.c_str());
+      std::cerr << "Failed to parse " << kind << " file: " << std::endl
+                << errors << std::endl;
       return 1;
     }
 
@@ -154,16 +156,16 @@ static int parseAndSaveValueTree(const Json::String& input,
     const bool parsingSuccessful =
         reader.parse(input.data(), input.data() + input.size(), *root);
     if (!parsingSuccessful) {
-      printf("Failed to parse %s file: \n%s\n", kind.c_str(),
-             reader.getFormattedErrorMessages().c_str());
+      std::cerr << "Failed to parse " << kind << " file: " << std::endl
+                << reader.getFormatedErrorMessages() << std::endl;
       return 1;
     }
   }
 
   if (!parseOnly) {
     FILE* factual = fopen(actual.c_str(), "wt");
     if (!factual) {
-      printf("Failed to create %s actual file.\n", kind.c_str());
+      std::cerr << "Failed to create '" << kind << "' actual file." << std::endl;
       return 2;
     }
     printValueTree(factual, *root);
@@ -197,7 +199,7 @@ static int rewriteValueTree(const Json::String& rewritePath,
   *rewrite = write(root);
   FILE* fout = fopen(rewritePath.c_str(), "wt");
   if (!fout) {
-    printf("Failed to create rewrite file: %s\n", rewritePath.c_str());
+    std::cerr << "Failed to create rewrite file: " << rewritePath << std::endl;
     return 2;
   }
   fprintf(fout, "%s\n", rewrite->c_str());
@@ -218,14 +220,14 @@ static Json::String removeSuffix(const Json::String& path,
 static void printConfig() {
 // Print the configuration used to compile JsonCpp
 #if defined(JSON_NO_INT64)
-  printf("JSON_NO_INT64=1\n");
+  std::cout << "JSON_NO_INT64=1" << std::endl;
 #else
-  printf("JSON_NO_INT64=0\n");
+  std::cout << "JSON_NO_INT64=0" << std::endl;
 #endif
 }
 
 static int printUsage(const char* argv[]) {
-  printf("Usage: %s [--strict] input-json-file", argv[0]);
+  std::cout << "Usage: " << argv[0] << " [--strict] input-json-file" << std::endl;
   return 3;
 }
 
@@ -255,7 +257,7 @@ static int parseCommandLine(int argc, const char* argv[], Options* opts) {
     } else if (writerName == "BuiltStyledStreamWriter") {
       opts->write = &useBuiltStyledStreamWriter;
     } else {
-      printf("Unknown '--json-writer %s'\n", writerName.c_str());
+      std::cerr << "Unknown '--json-writer' " << writerName << std::endl;
       return 4;
     }
   }
@@ -271,14 +273,13 @@ static int runTest(Options const& opts, bool use_legacy) {
 
   Json::String input = readInputTestFile(opts.path.c_str());
   if (input.empty()) {
-    printf("Failed to read input or empty input: %s\n", opts.path.c_str());
+    std::cerr << "Invalid input file: " << opts.path << std::endl;
     return 3;
   }
 
   Json::String basePath = removeSuffix(opts.path, ".json");
   if (!opts.parseOnly && basePath.empty()) {
-    printf("Bad input path. Path does not end with '.expected':\n%s\n",
-           opts.path.c_str());
+    std::cerr << "Bad input path '" << opts.path << "'. Must end with '.expected'" << std::endl;
     return 3;
   }
 
@@ -312,21 +313,22 @@ int main(int argc, const char* argv[]) {
   try {
     int exitCode = parseCommandLine(argc, argv, &opts);
     if (exitCode != 0) {
-      printf("Failed to parse command-line.");
+      std::cerr << "Failed to parse command-line." << std::endl;
       return exitCode;
     }
 
-    // TODO(baylesj): replace this with proper calls to both. Right now
-    // we only check the legacy if the modern one is not broken.
-    const int legacy_return_code = runTest(opts, true);
     const int modern_return_code = runTest(opts, false);
     if (modern_return_code) {
       return modern_return_code;
-    } else {
-      return legacy_return_code;
+    }
+
+    const std::string filename = opts.path.substr(opts.path.find_last_of("\\/") + 1);
+    const bool should_run_legacy = (filename.rfind("legacy_", 0) == 0);
+    if (should_run_legacy) {
+      return runTest(opts, true);
     }
   } catch (const std::exception& e) {
-    printf("Unhandled exception:\n%s\n", e.what());
+    std::cerr << "Unhandled exception:" << std::endl << e.what() << std::endl;
     return 1;
   }
 }

src/lib_json/json_reader.cpp

@@ -1531,14 +1531,14 @@ bool OurReader::decodeNumber(Token& token, Value& decoded) {
   // We assume we can represent the largest and smallest integer types as
   // unsigned integers with separate sign. This is only true if they can fit
   // into an unsigned integer.
-  static_assert(Value::maxLargestInt <= Value::maxLargestUInt);
+  static_assert(Value::maxLargestInt <= Value::maxLargestUInt, "Int must be smaller than UInt");
 
   // We need to convert minLargestInt into a positive number. The easiest way
   // to do this conversion is to assume our "threshold" value of minLargestInt
   // divided by 10 can fit in maxLargestInt when absolute valued. This should
   // be a safe assumption.
-  static_assert(Value::minLargestInt <= -Value::maxLargestInt);
-  static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt);
+  static_assert(Value::minLargestInt <= -Value::maxLargestInt, "The absolute value of minLargestInt must be greater than or equal to maxLargestInt");
+  static_assert(Value::minLargestInt / 10 >= -Value::maxLargestInt, "The absolute value of minLargestInt must be only 1 magnitude larger than maxLargest Int");
 
   static constexpr Value::LargestUInt positive_threshold =
       Value::maxLargestUInt / 10;