[flang][runtime] Allow extra character for E0.0 output editing

[klausler]

Summary

When the digit count ('d') is zero in E0 editing, allow for one more
output character; otherwise, any - or + sign in the output causes
an output field overflow.

flang/runtime/edit-output.cpp

   }
   if (editWidth == 0) { // "the processor selects the field width"
     if (edit.digits.has_value()) { // E0.d
-      editWidth = editDigits + 6; // -.666E+ee
+      if (editDigits == 0) { // E0.0
+        editWidth = 7; // -.0E+ee
+      } else {
+        editWidth = editDigits + 6; // -.666E+ee
+      }
     } else { // E0
       flags |= decimal::Minimize;
       significantDigits =

flang/unittests/Runtime/NumericalFormatTest.cpp

 using namespace Fortran::runtime::io;
 
 static bool CompareFormattedStrings(
-    const std::string &expect, const std::string &&got) {
+    const std::string &expect, const std::string &got) {
   std::string want{expect};
   want.resize(got.size(), ' ');
   return want == got;

 
 // Perform format and compare the result with expected value
 static bool CompareFormatReal(
-    const char *format, double x, const char *expect) {
+    const char *format, double x, const char *expect, std::string &got) {
   char buffer[800];
   auto cookie{IONAME(BeginInternalFormattedOutput)(
       buffer, sizeof buffer, format, std::strlen(format))};
   EXPECT_TRUE(IONAME(OutputReal64)(cookie, x));
   auto status{IONAME(EndIoStatement)(cookie)};
   EXPECT_EQ(status, 0);
-  return CompareFormattedStrings(expect, std::string{buffer, sizeof buffer});
+  got = std::string{buffer, sizeof buffer};
+  auto lastNonBlank{got.find_last_not_of(" ")};
+  if (lastNonBlank != std::string::npos) {
+    got.resize(lastNonBlank + 1);
+  }
+  return CompareFormattedStrings(expect, got);
 }
 
 // Convert raw uint64 into double, perform format, and compare with expected
-static bool CompareFormatReal(
-    const char *format, std::uint64_t xInt, const char *expect) {
+static bool CompareFormatReal(const char *format, std::uint64_t xInt,
+    const char *expect, std::string &got) {
   double x;
   static_assert(sizeof(double) == sizeof(std::uint64_t),
       "Size of double != size of uint64_t!");
   std::memcpy(&x, &xInt, sizeof xInt);
-  return CompareFormatReal(format, x, expect);
+  return CompareFormatReal(format, x, expect, got);
 }
 
 struct IOApiTests : CrashHandlerFixture {};

   };
 
   for (auto const &[format, expect] : zeroes) {
-    ASSERT_TRUE(CompareFormatReal(format, 0.0, expect))
-        << "Failed to format " << format << ", expected " << expect;
+    std::string got;
+    ASSERT_TRUE(CompareFormatReal(format, 0.0, expect, got))
+        << "Failed to format " << format << ", expected " << expect << ", got "
+        << got;
   }
 }
 

   };
 
   for (auto const &[format, expect] : ones) {
-    ASSERT_TRUE(CompareFormatReal(format, 1.0, expect))
-        << "Failed to format " << format << ", expected " << expect;
+    std::string got;
+    ASSERT_TRUE(CompareFormatReal(format, 1.0, expect, got))
+        << "Failed to format " << format << ", expected " << expect << ", got "
+        << got;
   }
 }
 

       {"(G0,';')", "-1.;"},
   };
   for (auto const &[format, expect] : negOnes) {
-    ASSERT_TRUE(CompareFormatReal(format, -1.0, expect))
-        << "Failed to format " << format << ", expected " << expect;
+    std::string got;
+    ASSERT_TRUE(CompareFormatReal(format, -1.0, expect, got))
+        << "Failed to format " << format << ", expected " << expect << ", got "
+        << got;
   }
 }
 

               {"(E62.55,';')",
                   " 0.1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},
-              {"(E0.0,';')", "0.E+00;"},
+              {"(E0.0,';')", " 0.E+00;"},
               {"(E0.55,';')",
                   "0.1000000000000000055511151231257827021181583404541015625E+"
                   "00;"},

 
   for (auto const &[value, cases] : testCases) {
     for (auto const &[format, expect] : cases) {
-      ASSERT_TRUE(CompareFormatReal(format, value, expect))
-          << "Failed to format " << format << ", expected " << expect;
+      std::string got;
+      ASSERT_TRUE(CompareFormatReal(format, value, expect, got))
+          << "Failed to format " << format << ", expected " << expect
+          << ", got " << got;
     }
   }
 

   };
 
   for (auto const &[format, value, expect] : individualTestCases) {
-    ASSERT_TRUE(CompareFormatReal(format, value, expect))
-        << "Failed to format " << format << ", expected " << expect;
+    std::string got;
+    ASSERT_TRUE(CompareFormatReal(format, value, expect, got))
+        << "Failed to format " << format << ", expected " << expect << ", got "
+        << got;
   }
 }