[flang] Update output format test to use GTest

[ashermancinelli]

Summary

Better document each test in output formatting tests. Use GTest primitives and infrastructure in same
spirit as D97403. See legacy github issue linked here for additional context. Reorganize long test cases to be more readable.

[klausler]

Has this version of the tests been validated for its ability to still find bugs in a broken runtime or decimal conversion library?

[ashermancinelli]

In D98303#2615397, @klausler wrote:

Has this version of the tests been validated for its ability to still find bugs in a broken runtime or decimal conversion library?

I apologize for my ignorance here - could you elaborate on this? Do you have a recommendation for how to go about intentionally breaking some component to ensure the tests still catch broken libraries?

[ashermancinelli]

Use fully qualified auto to address clang-tidy warnings.

[klausler]

In D98303#2615430, @ashermancinelli wrote:

In D98303#2615397, @klausler wrote:

Has this version of the tests been validated for its ability to still find bugs in a broken runtime or decimal conversion library?

I apologize for my ignorance here - could you elaborate on this? Do you have a recommendation for how to go about intentionally breaking some component to ensure the tests still catch broken libraries?

The existing version of this test works in the sense that it reliably fails when there's a bug in the Decimal library or in the code in the runtime that processes formatted output. Will your new version fail when there are bugs in those libraries? If you're not sure, then please don't replace the test until you are sure.

[ashermancinelli]

@klausler I reproduce all of the same test cases, so the test coverage should be identical and should catch all of the same bugs. I'd like to increase coverage, but the patch as-is should keep it the same.

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

42–45

I would be interested in any suggestions for how to better handle this case.

[awarzynski]

This is the first time I'm reading this and the additional comments are incredibly helpful. Thank you for all the effort @ashermancinelli !

In D98303#2615397, @klausler wrote:

Has this version of the tests been validated for its ability to still find bugs in a broken runtime or decimal conversion library?

I agree that we should try to preserve this capability. This should be possible with (I might be missing something):

• GTest test fixture
• call to RegisterCrashHandler in setUp

We could re-use CatchCrash from testing.cpp (it's likely that we will need to duplicate it for a short while). I think that we could test crash handling with LenTrimKind (try running it with some invalid arguments). More specifically, we need to trigger a call to terminator.Crash. This could be a implemented in a separate file IMHO (better - a separate patch).

@ashermancinelli , perhaps you could add some negative tests. This would increase the test coverage and improve the overall robustness of the tests. I would hope that for tests like HelloWorldOutputTest this should be rather straightforward. Perhaps trickier elsewhere.

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

76

ASSERT_FALSE suggests that we are expecting this to fail, but in fact this is testing for success (0 in this context means success, see here. I suggest ASSERT_EQ(status, 0) instead.

[klausler]

In D98303#2617264, @ashermancinelli wrote:

@klausler I reproduce all of the same test cases, so the test coverage should be identical and should catch all of the same bugs. I'd like to increase coverage, but the patch as-is should keep it the same.

I would like you to demonstrate that this new test does indeed properly report test failures when they occur.

[ashermancinelli]

@klausler I think I better understand your concerns now. How would you feel about this patch if I un-removed the original test, we refine this test, and ten

In D98303#2617385, @klausler wrote:

In D98303#2617264, @ashermancinelli wrote:

@klausler I reproduce all of the same test cases, so the test coverage should be identical and should catch all of the same bugs. I'd like to increase coverage, but the patch as-is should keep it the same.

I would like you to demonstrate that this new test does indeed properly report test failures when they occur.

In your opinion, would some death tests be sufficient? I can demonstrate some conditions under which many of these operations result in a runtime crash with the correct message, and in my opinion that would demonstrate proper failure reporting.

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

76

This is a great point, I'll address all instances of this I can find.

[awarzynski]

In D98303#2617981, @ashermancinelli wrote:

In your opinion, would some death tests be sufficient? I can demonstrate some conditions under which many of these operations result in a runtime crash with the correct message, and in my opinion that would demonstrate proper failure reporting.

I think that it's worthwhile to add a dedicated test for the crash handler API either way: https://reviews.llvm.org/D98601. This patch demonstrates that the message from the crash handler is indeed generated and printed to stdout.

Related to that, @ashermancinelli , do you know whether any of the methods tested here ever crash? This might be tricky to check. It might be easier to install a crash handler with Fortran::runtime::Terminator::RegisterCrashHandler like in the original test file.

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

99

IMHO, it would be better to dump to stderr so that it is possible to separate the regular output from GTest and other logging like this.

[ashermancinelli]

Rebase on recent main branch to incorporate terminator crash tests

[ashermancinelli]

@klausler D98652 hopefully demonstrates that runtime crashes are caught by death tests. This revision has been rebased on D98652 - I hope this sufficiently demonstrates that these tests accurately catch crashes. We could also work on another patch that intentionally crashes each of the APIs tested above not already tested in D98652.

[klausler]

In D98303#2636054, @ashermancinelli wrote:

@klausler D98652 hopefully demonstrates that runtime crashes are caught by death tests. This revision has been rebased on D98652 - I hope this sufficiently demonstrates that these tests accurately catch crashes. We could also work on another patch that intentionally crashes each of the APIs tested above not already tested in D98652.

I wasn't asking about crashes in the runtime. I was asking about catching incorrect results and reporting failures.

I will try again. If you modify the decimal or runtime library in such a way as to cause f18 to emit incorrectly formatted results, does your rewritten test fail? Let me know when you have confirmed this by observation.

[ashermancinelli]

In D98303#2636170, @klausler wrote:

In D98303#2636054, @ashermancinelli wrote:

@klausler D98652 hopefully demonstrates that runtime crashes are caught by death tests. This revision has been rebased on D98652 - I hope this sufficiently demonstrates that these tests accurately catch crashes. We could also work on another patch that intentionally crashes each of the APIs tested above not already tested in D98652.

I wasn't asking about crashes in the runtime. I was asking about catching incorrect results and reporting failures.

I will try again. If you modify the decimal or runtime library in such a way as to cause f18 to emit incorrectly formatted results, does your rewritten test fail? Let me know when you have confirmed this by observation.

After applying the breaking patch attached below, all tests fail except for IOApiTests.DescriptorOutputTest because I'm not familiar enough with the descriptor api to know how to break it. Please let me know if this is sufficient, and thanks for being understanding.

break-ioapi.patch5 KBDownload

ioapi-observe-failure.txt4 KBDownload

[ashermancinelli]

Fix clang-format and clang-tidy warnings.

[ashermancinelli]

Fix header include order.

[awarzynski]

LGTM, thank you for working on this! I've left a couple of comments, but these are [nit]s (feel free to ignore!).

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

42–45

Perhaps ASSERT_EQ(status, 0) would be better?

99

To clarify, I meant whole.Dump(stderr) instead of whole.Dump().

[ashermancinelli]

Use GTest EXPECT_EQ over potentially ambiguous return value, redirect SUT IO to stderr.

flang/unittests/Runtime/CMakeLists.txt

target_link_libraries(RuntimeTesting
   ${llvm_libs}
 )
 
 add_flang_nongtest_unittest(format
   RuntimeTesting
   FortranRuntime
 )
 
-add_flang_nongtest_unittest(hello
-  RuntimeTesting
-  FortranRuntime
-)
-
 # This test is not run by default as it requires input.
 add_executable(external-hello-world
   external-hello.cpp
 )
 
 target_link_libraries(external-hello-world
   FortranRuntime
 )

flang/unittests/Runtime/hello.cpp

-// Basic sanity tests of I/O API; exhaustive testing will be done in Fortran
-
-#include "testing.h"
-#include "../../runtime/descriptor.h"
-#include "../../runtime/io-api.h"
-#include <cstring>
-
-using namespace Fortran::runtime;
-using namespace Fortran::runtime::io;
-
-static bool test(const char *format, const char *expect, std::string &&got) {
-  std::string want{expect};
-  want.resize(got.length(), ' ');
-  if (got != want) {
-    Fail() << '\'' << format << "' failed;\n     got '" << got
-           << "',\nexpected '" << want << "'\n";
-    return false;
-  }
-  return true;
-}
-
-static void hello() {
-  char buffer[32];
-  const char *format{"(6HHELLO,,A6,2X,I3,1X,'0x',Z8,1X,L1)"};
-  auto cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, sizeof buffer, format, std::strlen(format))};
-  IONAME(OutputAscii)(cookie, "WORLD", 5);
-  IONAME(OutputInteger64)(cookie, 678);
-  IONAME(OutputInteger64)(cookie, 0xfeedface);
-  IONAME(OutputLogical)(cookie, true);
-  if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    Fail() << "hello: '" << format << "' failed, status "
-           << static_cast<int>(status) << '\n';
-  } else {
-    test(format, "HELLO, WORLD  678 0xFEEDFACE T",
-        std::string{buffer, sizeof buffer});
-  }
-}
-
-static void multiline() {
-  char buffer[5][32];
-  StaticDescriptor<1> staticDescriptor[2];
-  Descriptor &whole{staticDescriptor[0].descriptor()};
-  SubscriptValue extent[]{5};
-  whole.Establish(TypeCode{CFI_type_char}, sizeof buffer[0], &buffer, 1, extent,
-      CFI_attribute_pointer);
-  whole.Dump();
-  whole.Check();
-  Descriptor &section{staticDescriptor[1].descriptor()};
-  SubscriptValue lowers[]{0}, uppers[]{4}, strides[]{1};
-  section.Establish(whole.type(), whole.ElementBytes(), nullptr, 1, extent,
-      CFI_attribute_pointer);
-  if (auto error{
-          CFI_section(&section.raw(), &whole.raw(), lowers, uppers, strides)}) {
-    Fail() << "multiline: CFI_section failed: " << error << '\n';
-    return;
-  }
-  section.Dump();
-  section.Check();
-  const char *format{
-      "('?abcde,',T1,'>',T9,A,TL12,A,TR25,'<'//G0,17X,'abcd',1(2I4))"};
-  auto cookie{IONAME(BeginInternalArrayFormattedOutput)(
-      section, format, std::strlen(format))};
-  IONAME(OutputAscii)(cookie, "WORLD", 5);
-  IONAME(OutputAscii)(cookie, "HELLO", 5);
-  IONAME(OutputInteger64)(cookie, 789);
-  for (int j{666}; j <= 999; j += 111) {
-    IONAME(OutputInteger64)(cookie, j);
-  }
-  if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    Fail() << "multiline: '" << format << "' failed, status "
-           << static_cast<int>(status) << '\n';
-  } else {
-    test(format,
-        ">HELLO, WORLD                  <"
-        "                                "
-        "789                 abcd 666 777"
-        " 888 999                        "
-        "                                ",
-        std::string{buffer[0], sizeof buffer});
-  }
-}
-
-static void listInputTest() {
-  static const char input[]{",1*,(5.,6..)"};
-  auto cookie{IONAME(BeginInternalListInput)(input, sizeof input - 1)};
-  float z[6];
-  for (int j{0}; j < 6; ++j) {
-    z[j] = -(j + 1);
-  }
-  for (int j{0}; j < 6; j += 2) {
-    if (!IONAME(InputComplex32)(cookie, &z[j])) {
-      Fail() << "InputComplex32 failed\n";
-    }
-  }
-  auto status{IONAME(EndIoStatement)(cookie)};
-  if (status) {
-    Fail() << "Failed complex list-directed input, status "
-           << static_cast<int>(status) << '\n';
-  } else {
-    char output[33];
-    output[32] = '\0';
-    cookie = IONAME(BeginInternalListOutput)(output, 32);
-    for (int j{0}; j < 6; j += 2) {
-      if (!IONAME(OutputComplex32)(cookie, z[j], z[j + 1])) {
-        Fail() << "OutputComplex32 failed\n";
-      }
-    }
-    status = IONAME(EndIoStatement)(cookie);
-    static const char expect[33]{" (-1.,-2.) (-3.,-4.) (5.,6.)    "};
-    if (status) {
-      Fail() << "Failed complex list-directed output, status "
-             << static_cast<int>(status) << '\n';
-    } else if (std::strncmp(output, expect, 33) != 0) {
-      Fail() << "Failed complex list-directed output, expected '" << expect
-             << "', but got '" << output << "'\n";
-    }
-  }
-}
-
-static void descrOutputTest() {
-  char buffer[9];
-  // Formatted
-  const char *format{"(2A4)"};
-  auto cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, sizeof buffer, format, std::strlen(format))};
-  StaticDescriptor<1> staticDescriptor;
-  Descriptor &desc{staticDescriptor.descriptor()};
-  SubscriptValue extent[]{2};
-  char data[2][4];
-  std::memcpy(data[0], "ABCD", 4);
-  std::memcpy(data[1], "EFGH", 4);
-  desc.Establish(TypeCode{CFI_type_char}, sizeof data[0], &data, 1, extent);
-  desc.Dump();
-  desc.Check();
-  IONAME(OutputDescriptor)(cookie, desc);
-  if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    Fail() << "descrOutputTest: '" << format << "' failed, status "
-           << static_cast<int>(status) << '\n';
-  } else {
-    test("descrOutputTest(formatted)", "ABCDEFGH ",
-        std::string{buffer, sizeof buffer});
-  }
-  // List-directed
-  cookie = IONAME(BeginInternalListOutput)(buffer, sizeof buffer);
-  IONAME(OutputDescriptor)(cookie, desc);
-  if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    Fail() << "descrOutputTest: list-directed failed, status "
-           << static_cast<int>(status) << '\n';
-  } else {
-    test("descrOutputTest(list)", " ABCDEFGH",
-        std::string{buffer, sizeof buffer});
-  }
-}
-
-static void realTest(const char *format, double x, const char *expect) {
-  char buffer[800];
-  auto cookie{IONAME(BeginInternalFormattedOutput)(
-      buffer, sizeof buffer, format, std::strlen(format))};
-  IONAME(OutputReal64)(cookie, x);
-  if (auto status{IONAME(EndIoStatement)(cookie)}) {
-    Fail() << '\'' << format << "' failed, status " << static_cast<int>(status)
-           << '\n';
-  } else {
-    test(format, expect, std::string{buffer, sizeof buffer});
-  }
-}
-
-static void realInTest(
-    const char *format, const char *data, std::uint64_t want) {
-  auto cookie{IONAME(BeginInternalFormattedInput)(
-      data, std::strlen(data), format, std::strlen(format))};
-  union {
-    double x;
-    std::uint64_t raw;
-  } u;
-  u.raw = 0;
-  IONAME(EnableHandlers)(cookie, true, true, true, true, true);
-  IONAME(InputReal64)(cookie, u.x);
-  char iomsg[65];
-  iomsg[0] = '\0';
-  iomsg[sizeof iomsg - 1] = '\0';
-  IONAME(GetIoMsg)(cookie, iomsg, sizeof iomsg - 1);
-  auto status{IONAME(EndIoStatement)(cookie)};
-  if (status) {
-    Fail() << '\'' << format << "' failed reading '" << data << "', status "
-           << static_cast<int>(status) << " iomsg '" << iomsg << "'\n";
-  } else if (u.raw != want) {
-    Fail() << '\'' << format << "' failed reading '" << data << "', want 0x";
-    Fail().write_hex(want) << ", got 0x" << u.raw << '\n';
-  }
-}
-
-int main() {
-  StartTests();
-
-  hello();
-  multiline();
-
-  static const char *zeroes[][2]{
-      {"(E32.17,';')", "         0.00000000000000000E+00;"},
-      {"(F32.17,';')", "             0.00000000000000000;"},
-      {"(G32.17,';')", "          0.0000000000000000    ;"},
-      {"(DC,E32.17,';')", "         0,00000000000000000E+00;"},
-      {"(DC,F32.17,';')", "             0,00000000000000000;"},
-      {"(DC,G32.17,';')", "          0,0000000000000000    ;"},
-      {"(D32.17,';')", "         0.00000000000000000D+00;"},
-      {"(E32.17E1,';')", "          0.00000000000000000E+0;"},
-      {"(G32.17E1,';')", "           0.0000000000000000   ;"},
-      {"(E32.17E0,';')", "          0.00000000000000000E+0;"},
-      {"(G32.17E0,';')", "          0.0000000000000000    ;"},
-      {"(1P,E32.17,';')", "         0.00000000000000000E+00;"},
-      {"(1PE32.17,';')", "         0.00000000000000000E+00;"}, // no comma
-      {"(1P,F32.17,';')", "             0.00000000000000000;"},
-      {"(1P,G32.17,';')", "          0.0000000000000000    ;"},
-      {"(2P,E32.17,';')", "         00.0000000000000000E+00;"},
-      {"(-1P,E32.17,';')", "         0.00000000000000000E+00;"},
-      {"(G0,';')", "0.;"}, {}};
-  for (int j{0}; zeroes[j][0]; ++j) {
-    realTest(zeroes[j][0], 0.0, zeroes[j][1]);
-  }
-
-  static const char *ones[][2]{
-      {"(E32.17,';')", "         0.10000000000000000E+01;"},
-      {"(F32.17,';')", "             1.00000000000000000;"},
-      {"(G32.17,';')", "          1.0000000000000000    ;"},
-      {"(E32.17E1,';')", "          0.10000000000000000E+1;"},
-      {"(G32.17E1,';')", "           1.0000000000000000   ;"},
-      {"(E32.17E0,';')", "          0.10000000000000000E+1;"},
-      {"(G32.17E0,';')", "          1.0000000000000000    ;"},
-      {"(E32.17E4,';')", "       0.10000000000000000E+0001;"},
-      {"(G32.17E4,';')", "        1.0000000000000000      ;"},
-      {"(1P,E32.17,';')", "         1.00000000000000000E+00;"},
-      {"(1PE32.17,';')", "         1.00000000000000000E+00;"}, // no comma
-      {"(1P,F32.17,';')", "            10.00000000000000000;"},
-      {"(1P,G32.17,';')", "          1.0000000000000000    ;"},
-      {"(ES32.17,';')", "         1.00000000000000000E+00;"},
-      {"(2P,E32.17,';')", "         10.0000000000000000E-01;"},
-      {"(2P,G32.17,';')", "          1.0000000000000000    ;"},
-      {"(-1P,E32.17,';')", "         0.01000000000000000E+02;"},
-      {"(-1P,G32.17,';')", "          1.0000000000000000    ;"},
-      {"(G0,';')", "1.;"}, {}};
-  for (int j{0}; ones[j][0]; ++j) {
-    realTest(ones[j][0], 1.0, ones[j][1]);
-  }
-
-  realTest("(E32.17,';')", -1.0, "        -0.10000000000000000E+01;");
-  realTest("(F32.17,';')", -1.0, "            -1.00000000000000000;");
-  realTest("(G32.17,';')", -1.0, "         -1.0000000000000000    ;");
-  realTest("(G0,';')", -1.0, "-1.;");
-
-  volatile union {
-    double d;
-    std::uint64_t n;
-  } u;
-  u.n = 0x8000000000000000; // -0
-  realTest("(E9.1,';')", u.d, " -0.0E+00;");
-  realTest("(F4.0,';')", u.d, " -0.;");
-  realTest("(G8.0,';')", u.d, "-0.0E+00;");
-  realTest("(G8.1,';')", u.d, " -0.    ;");
-  realTest("(G0,';')", u.d, "-0.;");
-  u.n = 0x7ff0000000000000; // +Inf
-  realTest("(E9.1,';')", u.d, "      Inf;");
-  realTest("(F9.1,';')", u.d, "      Inf;");
-  realTest("(G9.1,';')", u.d, "      Inf;");
-  realTest("(SP,E9.1,';')", u.d, "     +Inf;");
-  realTest("(SP,F9.1,';')", u.d, "     +Inf;");
-  realTest("(SP,G9.1,';')", u.d, "     +Inf;");
-  realTest("(G0,';')", u.d, "Inf;");
-  u.n = 0xfff0000000000000; // -Inf
-  realTest("(E9.1,';')", u.d, "     -Inf;");
-  realTest("(F9.1,';')", u.d, "     -Inf;");
-  realTest("(G9.1,';')", u.d, "     -Inf;");
-  realTest("(G0,';')", u.d, "-Inf;");
-  u.n = 0x7ff0000000000001; // NaN
-  realTest("(E9.1,';')", u.d, "      NaN;");
-  realTest("(F9.1,';')", u.d, "      NaN;");
-  realTest("(G9.1,';')", u.d, "      NaN;");
-  realTest("(G0,';')", u.d, "NaN;");
-  u.n = 0xfff0000000000001; // NaN (sign irrelevant)
-  realTest("(E9.1,';')", u.d, "      NaN;");
-  realTest("(F9.1,';')", u.d, "      NaN;");
-  realTest("(G9.1,';')", u.d, "      NaN;");
-  realTest("(SP,E9.1,';')", u.d, "      NaN;");
-  realTest("(SP,F9.1,';')", u.d, "      NaN;");
-  realTest("(SP,G9.1,';')", u.d, "      NaN;");
-  realTest("(G0,';')", u.d, "NaN;");
-
-  u.n = 0x3fb999999999999a; // 0.1 rounded
-  realTest("(E62.55,';')", u.d,
-      " 0.1000000000000000055511151231257827021181583404541015625E+00;");
-  realTest("(E0.0,';')", u.d, "0.E+00;");
-  realTest("(E0.55,';')", u.d,
-      "0.1000000000000000055511151231257827021181583404541015625E+00;");
-  realTest("(E0,';')", u.d, ".1E+00;");
-  realTest("(F58.55,';')", u.d,
-      " 0.1000000000000000055511151231257827021181583404541015625;");
-  realTest("(F0.0,';')", u.d, "0.;");
-  realTest("(F0.55,';')", u.d,
-      ".1000000000000000055511151231257827021181583404541015625;");
-  realTest("(F0,';')", u.d, ".1;");
-  realTest("(G62.55,';')", u.d,
-      " 0.1000000000000000055511151231257827021181583404541015625    ;");
-  realTest("(G0.0,';')", u.d, "0.;");
-  realTest("(G0.55,';')", u.d,
-      ".1000000000000000055511151231257827021181583404541015625;");
-  realTest("(G0,';')", u.d, ".1;");
-
-  u.n = 0x3ff8000000000000; // 1.5
-  realTest("(E9.2,';')", u.d, " 0.15E+01;");
-  realTest("(F4.1,';')", u.d, " 1.5;");
-  realTest("(G7.1,';')", u.d, " 2.    ;");
-  realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RN,F3.0,';')", u.d, " 2.;");
-  realTest("(RN,G7.0,';')", u.d, " 0.E+01;");
-  realTest("(RN,G7.1,';')", u.d, " 2.    ;");
-  realTest("(RD,E8.1,';')", u.d, " 0.1E+01;");
-  realTest("(RD,F3.0,';')", u.d, " 1.;");
-  realTest("(RD,G7.0,';')", u.d, " 0.E+01;");
-  realTest("(RD,G7.1,';')", u.d, " 1.    ;");
-  realTest("(RU,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RU,G7.0,';')", u.d, " 0.E+01;");
-  realTest("(RU,G7.1,';')", u.d, " 2.    ;");
-  realTest("(RZ,E8.1,';')", u.d, " 0.1E+01;");
-  realTest("(RZ,F3.0,';')", u.d, " 1.;");
-  realTest("(RZ,G7.0,';')", u.d, " 0.E+01;");
-  realTest("(RZ,G7.1,';')", u.d, " 1.    ;");
-  realTest("(RC,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RC,F3.0,';')", u.d, " 2.;");
-  realTest("(RC,G7.0,';')", u.d, " 0.E+01;");
-  realTest("(RC,G7.1,';')", u.d, " 2.    ;");
-
-  // TODO continue F and G editing tests on these data
-
-  u.n = 0xbff8000000000000; // -1.5
-  realTest("(E9.2,';')", u.d, "-0.15E+01;");
-  realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
-  realTest("(RD,E8.1,';')", u.d, "-0.2E+01;");
-  realTest("(RU,E8.1,';')", u.d, "-0.1E+01;");
-  realTest("(RZ,E8.1,';')", u.d, "-0.1E+01;");
-  realTest("(RC,E8.1,';')", u.d, "-0.2E+01;");
-
-  u.n = 0x4004000000000000; // 2.5
-  realTest("(E9.2,';')", u.d, " 0.25E+01;");
-  realTest("(RN,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RD,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RU,E8.1,';')", u.d, " 0.3E+01;");
-  realTest("(RZ,E8.1,';')", u.d, " 0.2E+01;");
-  realTest("(RC,E8.1,';')", u.d, " 0.3E+01;");
-
-  u.n = 0xc004000000000000; // -2.5
-  realTest("(E9.2,';')", u.d, "-0.25E+01;");
-  realTest("(RN,E8.1,';')", u.d, "-0.2E+01;");
-  realTest("(RD,E8.1,';')", u.d, "-0.3E+01;");
-  realTest("(RU,E8.1,';')", u.d, "-0.2E+01;");
-  realTest("(RZ,E8.1,';')", u.d, "-0.2E+01;");
-  realTest("(RC,E8.1,';')", u.d, "-0.3E+01;");
-
-  u.n = 1; // least positive nonzero subnormal
-  realTest("(E32.17,';')", u.d, "         0.49406564584124654-323;");
-  realTest("(ES32.17,';')", u.d, "         4.94065645841246544-324;");
-  realTest("(EN32.17,';')", u.d, "         4.94065645841246544-324;");
-  realTest("(E759.752,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "75386825064197182655334472656250-323;");
-  realTest("(G0,';')", u.d, ".5-323;");
-  realTest("(E757.750,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "753868250641971826553344726562-323;");
-  realTest("(RN,E757.750,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "753868250641971826553344726562-323;");
-  realTest("(RD,E757.750,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "753868250641971826553344726562-323;");
-  realTest("(RU,E757.750,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "753868250641971826553344726563-323;");
-  realTest("(RC,E757.750,';')", u.d,
-      " 0."
-      "494065645841246544176568792868221372365059802614324764425585682500675507"
-      "270208751865299836361635992379796564695445717730926656710355939796398774"
-      "796010781878126300713190311404527845817167848982103688718636056998730723"
-      "050006387409153564984387312473397273169615140031715385398074126238565591"
-      "171026658556686768187039560310624931945271591492455329305456544401127480"
-      "129709999541931989409080416563324524757147869014726780159355238611550134"
-      "803526493472019379026810710749170333222684475333572083243193609238289345"
-      "836806010601150616980975307834227731832924790498252473077637592724787465"
-      "608477820373446969953364701797267771758512566055119913150489110145103786"
-      "273816725095583738973359899366480994116420570263709027924276754456522908"
-      "753868250641971826553344726563-323;");
-
-  u.n = 0x10000000000000; // least positive nonzero normal
-  realTest("(E723.716,';')", u.d,
-      " 0."
-      "222507385850720138309023271733240406421921598046233183055332741688720443"
-      "481391819585428315901251102056406733973103581100515243416155346010885601"
-      "238537771882113077799353200233047961014744258363607192156504694250373420"
-      "837525080665061665815894872049117996859163964850063590877011830487479978"
-      "088775374994945158045160505091539985658247081864511353793580499211598108"
-      "576605199243335211435239014879569960959128889160299264151106346631339366"
-      "347758651302937176204732563178148566435087212282863764204484681140761391"
-      "147706280168985324411002416144742161856716615054015428508471675290190316"
-      "132277889672970737312333408698898317506783884692609277397797285865965494"
-      "10913690954061364675687023986783152906809846172109246253967285156250-"
-      "307;");
-  realTest("(G0,';')", u.d, ".22250738585072014-307;");
-
-  u.n = 0x7fefffffffffffffuLL; // greatest finite
-  realTest("(E32.17,';')", u.d, "         0.17976931348623157+309;");
-  realTest("(E317.310,';')", u.d,
-      " 0."
-      "179769313486231570814527423731704356798070567525844996598917476803157260"
-      "780028538760589558632766878171540458953514382464234321326889464182768467"
-      "546703537516986049910576551282076245490090389328944075868508455133942304"
-      "583236903222948165808559332123348274797826204144723168738177180919299881"
-      "2504040261841248583680+309;");
-  realTest("(ES317.310,';')", u.d,
-      " 1."
-      "797693134862315708145274237317043567980705675258449965989174768031572607"
-      "800285387605895586327668781715404589535143824642343213268894641827684675"
-      "467035375169860499105765512820762454900903893289440758685084551339423045"
-      "832369032229481658085593321233482747978262041447231687381771809192998812"
-      "5040402618412485836800+308;");
-  realTest("(EN319.310,';')", u.d,
-      " 179."
-      "769313486231570814527423731704356798070567525844996598917476803157260780"
-      "028538760589558632766878171540458953514382464234321326889464182768467546"
-      "703537516986049910576551282076245490090389328944075868508455133942304583"
-      "236903222948165808559332123348274797826204144723168738177180919299881250"
-      "4040261841248583680000+306;");
-  realTest("(G0,';')", u.d, ".17976931348623157+309;");
-
-  realTest("(F5.3,';')", 25., "*****;");
-  realTest("(F5.3,';')", 2.5, "2.500;");
-  realTest("(F5.3,';')", 0.25, "0.250;");
-  realTest("(F5.3,';')", 0.025, "0.025;");
-  realTest("(F5.3,';')", 0.0025, "0.003;");
-  realTest("(F5.3,';')", 0.00025, "0.000;");
-  realTest("(F5.3,';')", 0.000025, "0.000;");
-  realTest("(F5.3,';')", -25., "*****;");
-  realTest("(F5.3,';')", -2.5, "*****;");
-  realTest("(F5.3,';')", -0.25, "-.250;");
-  realTest("(F5.3,';')", -0.025, "-.025;");
-  realTest("(F5.3,';')", -0.0025, "-.003;");
-  realTest("(F5.3,';')", -0.00025, "-.000;");
-  realTest("(F5.3,';')", -0.000025, "-.000;");
-
-  realInTest("(F18.0)", "                 0", 0x0);
-  realInTest("(F18.0)", "                  ", 0x0);
-  realInTest("(F18.0)", "                -0", 0x8000000000000000);
-  realInTest("(F18.0)", "                01", 0x3ff0000000000000);
-  realInTest("(F18.0)", "                 1", 0x3ff0000000000000);
-  realInTest("(F18.0)", "              125.", 0x405f400000000000);
-  realInTest("(F18.0)", "              12.5", 0x4029000000000000);
-  realInTest("(F18.0)", "              1.25", 0x3ff4000000000000);
-  realInTest("(F18.0)", "             01.25", 0x3ff4000000000000);
-  realInTest("(F18.0)", "              .125", 0x3fc0000000000000);
-  realInTest("(F18.0)", "             0.125", 0x3fc0000000000000);
-  realInTest("(F18.0)", "             .0625", 0x3fb0000000000000);
-  realInTest("(F18.0)", "            0.0625", 0x3fb0000000000000);
-  realInTest("(F18.0)", "               125", 0x405f400000000000);
-  realInTest("(F18.1)", "               125", 0x4029000000000000);
-  realInTest("(F18.2)", "               125", 0x3ff4000000000000);
-  realInTest("(F18.3)", "               125", 0x3fc0000000000000);
-  realInTest("(-1P,F18.0)", "               125", 0x4093880000000000); // 1250
-  realInTest("(1P,F18.0)", "               125", 0x4029000000000000); // 12.5
-  realInTest("(BZ,F18.0)", "              125 ", 0x4093880000000000); // 1250
-  realInTest("(BZ,F18.0)", "       125 . e +1 ", 0x42a6bcc41e900000); // 1.25e13
-  realInTest("(DC,F18.0)", "              12,5", 0x4029000000000000);
-
-  listInputTest();
-  descrOutputTest();
-
-  return EndTests();
-}

flang/unittests/RuntimeGTest/CMakeLists.txt

 add_flang_unittest(FlangRuntimeTests
   CharacterTest.cpp
   RuntimeCrashTest.cpp
   CrashHandlerFixture.cpp
+  NumericalFormatTest.cpp
+  RuntimeCrashTest.cpp
+  CrashHandlerFixture.cpp
 )
 
 target_link_libraries(FlangRuntimeTests
   PRIVATE
   FortranRuntime
 )

flang/unittests/RuntimeGTest/NumericalFormatTest.cpp

+//===-- flang/unittests/RuntimeGTest/NumericalFormatTest.cpp ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "CrashHandlerFixture.h"
+#include "../../runtime/descriptor.h"
+#include "../../runtime/io-api.h"
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <gtest/gtest.h>
+#include <tuple>
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
+
+static bool CompareFormattedStrings(
+    const std::string &expect, const std::string &&got) {
+  std::string want{expect};
+  want.resize(got.size(), ' ');
+  return want == got;
+}
+
+static bool CompareFormattedStrings(
+    const char *expect, const std::string &&got) {
+  return CompareFormattedStrings(std::string(expect), std::move(got));
+}
+
+// Perform format and compare the result with expected value
+static bool CompareFormatReal(
+    const char *format, double x, const char *expect) {
+  char buffer[800];
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, sizeof buffer, format, std::strlen(format))};
+  IONAME(OutputReal64)(cookie, x);
+  auto status{IONAME(EndIoStatement)(cookie)};
+
+  EXPECT_EQ(status, 0);
+  return CompareFormattedStrings(expect, std::string{buffer, sizeof buffer});
+}
+
+// Convert raw uint64 into double, perform format, and compare with expected
+static bool CompareFormatReal(
+    const char *format, std::uint64_t xInt, const char *expect) {
+  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);
+}
+
+struct IOApiTests : CrashHandlerFixture {};
+
+TEST(IOApiTests, HelloWorldOutputTest) {
+  static constexpr int bufferSize{32};
+  char buffer[bufferSize];
+
+  // Create format for all types and values to be written
+  const char *format{"(6HHELLO,,A6,2X,I3,1X,'0x',Z8,1X,L1)"};
+  auto *cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, bufferSize, format, std::strlen(format))};
+
+  // Write string, integer, and logical values to buffer
+  IONAME(OutputAscii)(cookie, "WORLD", 5);
+  IONAME(OutputInteger64)(cookie, 678);
+  IONAME(OutputInteger64)(cookie, 0xfeedface);
+  IONAME(OutputLogical)(cookie, true);
+
+  // Ensure IO succeeded
+  auto status{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(status, 0) << "hello: '" << format << "' failed, status "
+                       << static_cast<int>(status);
+
+  // Ensure final buffer matches expected string output
+  static const std::string expect{"HELLO, WORLD  678 0xFEEDFACE T"};
+  ASSERT_TRUE(
+      CompareFormattedStrings(expect, std::string{buffer, sizeof buffer}))
+      << "Expected '" << expect << "', got " << buffer;
+}
+
+TEST(IOApiTests, MultilineOutputTest) {
+  // Allocate buffer for multiline output
+  static constexpr int numLines{5};
+  static constexpr int lineLength{32};
+  static char buffer[numLines][lineLength];
+
+  // Create descriptor for entire buffer
+  static constexpr int staticDescriptorMaxRank{1};
+  static StaticDescriptor<staticDescriptorMaxRank> wholeStaticDescriptor;
+  static Descriptor &whole{wholeStaticDescriptor.descriptor()};
+  static SubscriptValue extent[]{numLines};
+  whole.Establish(TypeCode{CFI_type_char}, /*elementBytes=*/lineLength, &buffer,
+      staticDescriptorMaxRank, extent, CFI_attribute_pointer);
+  whole.Dump(stderr);
+  whole.Check();
+
+  // Create descriptor for buffer section
+  static StaticDescriptor<staticDescriptorMaxRank> sectionStaticDescriptor;
+  static Descriptor &section{sectionStaticDescriptor.descriptor()};
+  static const SubscriptValue lowers[]{0}, uppers[]{4}, strides[]{1};
+  section.Establish(whole.type(), /*elementBytes=*/whole.ElementBytes(),
+      nullptr, /*maxRank=*/staticDescriptorMaxRank, extent,
+      CFI_attribute_pointer);
+
+  // Ensure C descriptor address `section.raw()` is updated without error
+  const auto error{
+      CFI_section(&section.raw(), &whole.raw(), lowers, uppers, strides)};
+  ASSERT_EQ(error, 0) << "multiline: CFI_section failed: " << error;
+  section.Dump(stderr);
+  section.Check();
+
+  // Create format string and initialize IO operation
+  const char *format{
+      "('?abcde,',T1,'>',T9,A,TL12,A,TR25,'<'//G0,17X,'abcd',1(2I4))"};
+  static auto *cookie{IONAME(BeginInternalArrayFormattedOutput)(
+      section, format, std::strlen(format))};
+
+  // Write data to buffer
+  IONAME(OutputAscii)(cookie, "WORLD", 5);
+  IONAME(OutputAscii)(cookie, "HELLO", 5);
+  IONAME(OutputInteger64)(cookie, 789);
+  for (int j{666}; j <= 999; j += 111) {
+    IONAME(OutputInteger64)(cookie, j);
+  }
+
+  // Ensure no errors occured in write operations above
+  const auto status{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(status, 0) << "multiline: '" << format << "' failed, status "
+                       << static_cast<int>(status);
+
+  static const std::string expect{">HELLO, WORLD                  <"
+                                  "                                "
+                                  "789                 abcd 666 777"
+                                  " 888 999                        "
+                                  "                                "};
+  // Ensure formatted string matches expected output
+  ASSERT_TRUE(
+      CompareFormattedStrings(expect, std::string{buffer[0], sizeof buffer}))
+      << "Expected " << expect << " but got " << buffer;
+}
+
+TEST(IOApiTests, ListInputTest) {
+  static const char input[]{",1*,(5.,6..)"};
+  static auto *cookie{IONAME(BeginInternalListInput)(input, sizeof input - 1)};
+
+  // Create real values for IO tests
+  static constexpr int numRealValues{6};
+  static float z[numRealValues];
+  for (int j{0}; j < numRealValues; ++j) {
+    z[j] = -(j + 1);
+  }
+
+  // Ensure reading complex values to floats does not result in an error
+  for (int j{0}; j < numRealValues; j += 2) {
+    ASSERT_TRUE(IONAME(InputComplex32)(cookie, &z[j]))
+        << "InputComplex32 failed with value " << z[j];
+  }
+
+  // Ensure no IO errors occured during IO operations above
+  static auto status{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(status, 0) << "Failed complex list-directed input, status "
+                       << static_cast<int>(status);
+
+  // Ensure writing complex values from floats does not result in an error
+  static constexpr int bufferSize{33};
+  static char output[bufferSize];
+  output[bufferSize - 1] = '\0';
+  cookie = IONAME(BeginInternalListOutput)(output, bufferSize - 1);
+  for (int j{0}; j < numRealValues; j += 2) {
+    ASSERT_TRUE(IONAME(OutputComplex32)(cookie, z[j], z[j + 1]))
+        << "OutputComplex32 failed when outputting value " << z[j] << ", "
+        << z[j + 1];
+  }
+
+  // Ensure no IO errors occured during IO operations above
+  status = IONAME(EndIoStatement)(cookie);
+  ASSERT_EQ(status, 0) << "Failed complex list-directed output, status "
+                       << static_cast<int>(status);
+
+  // Verify output buffer against expected value
+  static const char expect[bufferSize]{" (-1.,-2.) (-3.,-4.) (5.,6.)    "};
+  ASSERT_EQ(std::strncmp(output, expect, bufferSize), 0)
+      << "Failed complex list-directed output, expected '" << expect
+      << "', but got '" << output << "'";
+}
+
+TEST(IOApiTests, DescriptorOutputTest) {
+  static constexpr int bufferSize{9};
+  static char buffer[bufferSize];
+  static const char *format{"(2A4)"};
+  static auto *cookie{IONAME(BeginInternalFormattedOutput)(
+      buffer, bufferSize, format, std::strlen(format))};
+
+  // Create descriptor for output
+  static constexpr int staticDescriptorMaxRank{1};
+  static StaticDescriptor<staticDescriptorMaxRank> staticDescriptor;
+  static Descriptor &desc{staticDescriptor.descriptor()};
+  static constexpr int subscriptExtent{2};
+  static const SubscriptValue extent[]{subscriptExtent};
+
+  // Manually write to descriptor buffer
+  static constexpr int dataLength{4};
+  static char data[subscriptExtent][dataLength];
+  std::memcpy(data[0], "ABCD", dataLength);
+  std::memcpy(data[1], "EFGH", dataLength);
+  desc.Establish(TypeCode{CFI_type_char}, dataLength, &data,
+      staticDescriptorMaxRank, extent);
+  desc.Dump(stderr);
+  desc.Check();
+  IONAME(OutputDescriptor)(cookie, desc);
+
+  // Ensure no errors were encountered in initializing the cookie and descriptor
+  static auto formatStatus{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(formatStatus, 0)
+      << "descrOutputTest: '" << format << "' failed, status "
+      << static_cast<int>(formatStatus);
+
+  // Ensure buffer matches expected output
+  ASSERT_TRUE(
+      CompareFormattedStrings("ABCDEFGH ", std::string{buffer, sizeof buffer}));
+
+  // Begin list-directed output on cookie by descriptor
+  cookie = IONAME(BeginInternalListOutput)(buffer, sizeof buffer);
+  IONAME(OutputDescriptor)(cookie, desc);
+
+  // Ensure list-directed output does not result in an IO error
+  static auto listDirectedStatus{IONAME(EndIoStatement)(cookie)};
+  ASSERT_EQ(listDirectedStatus, 0)
+      << "descrOutputTest: list-directed failed, status "
+      << static_cast<int>(listDirectedStatus);
+
+  // Ensure buffer matches expected output
+  ASSERT_TRUE(
+      CompareFormattedStrings(" ABCDEFGH", std::string{buffer, sizeof buffer}));
+}
+
+//------------------------------------------------------------------------------
+/// Tests for output formatting real values
+//------------------------------------------------------------------------------
+
+TEST(IOApiTests, FormatZeroes) {
+  static constexpr std::pair<const char *, const char *> zeroes[]{
+      {"(E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(F32.17,';')", "             0.00000000000000000;"},
+      {"(G32.17,';')", "          0.0000000000000000    ;"},
+      {"(DC,E32.17,';')", "         0,00000000000000000E+00;"},
+      {"(DC,F32.17,';')", "             0,00000000000000000;"},
+      {"(DC,G32.17,';')", "          0,0000000000000000    ;"},
+      {"(D32.17,';')", "         0.00000000000000000D+00;"},
+      {"(E32.17E1,';')", "          0.00000000000000000E+0;"},
+      {"(G32.17E1,';')", "           0.0000000000000000   ;"},
+      {"(E32.17E0,';')", "          0.00000000000000000E+0;"},
+      {"(G32.17E0,';')", "          0.0000000000000000    ;"},
+      {"(1P,E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(1PE32.17,';')", "         0.00000000000000000E+00;"}, // no comma
+      {"(1P,F32.17,';')", "             0.00000000000000000;"},
+      {"(1P,G32.17,';')", "          0.0000000000000000    ;"},
+      {"(2P,E32.17,';')", "         00.0000000000000000E+00;"},
+      {"(-1P,E32.17,';')", "         0.00000000000000000E+00;"},
+      {"(G0,';')", "0.;"},
+  };
+
+  for (auto const &[format, expect] : zeroes) {
+    ASSERT_TRUE(CompareFormatReal(format, 0.0, expect))
+        << "Failed to format " << format << ", expected " << expect;
+  }
+}
+
+TEST(IOApiTests, FormatOnes) {
+  static constexpr std::pair<const char *, const char *> ones[]{
+      {"(E32.17,';')", "         0.10000000000000000E+01;"},
+      {"(F32.17,';')", "             1.00000000000000000;"},
+      {"(G32.17,';')", "          1.0000000000000000    ;"},
+      {"(E32.17E1,';')", "          0.10000000000000000E+1;"},
+      {"(G32.17E1,';')", "           1.0000000000000000   ;"},
+      {"(E32.17E0,';')", "          0.10000000000000000E+1;"},
+      {"(G32.17E0,';')", "          1.0000000000000000    ;"},
+      {"(E32.17E4,';')", "       0.10000000000000000E+0001;"},
+      {"(G32.17E4,';')", "        1.0000000000000000      ;"},
+      {"(1P,E32.17,';')", "         1.00000000000000000E+00;"},
+      {"(1PE32.17,';')", "         1.00000000000000000E+00;"}, // no comma
+      {"(1P,F32.17,';')", "            10.00000000000000000;"},
+      {"(1P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(ES32.17,';')", "         1.00000000000000000E+00;"},
+      {"(2P,E32.17,';')", "         10.0000000000000000E-01;"},
+      {"(2P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(-1P,E32.17,';')", "         0.01000000000000000E+02;"},
+      {"(-1P,G32.17,';')", "          1.0000000000000000    ;"},
+      {"(G0,';')", "1.;"},
+  };
+
+  for (auto const &[format, expect] : ones) {
+    ASSERT_TRUE(CompareFormatReal(format, 1.0, expect))
+        << "Failed to format " << format << ", expected " << expect;
+  }
+}
+
+TEST(IOApiTests, FormatNegativeOnes) {
+  static constexpr std::tuple<const char *, const char *> negOnes[]{
+      {"(E32.17,';')", "        -0.10000000000000000E+01;"},
+      {"(F32.17,';')", "            -1.00000000000000000;"},
+      {"(G32.17,';')", "         -1.0000000000000000    ;"},
+      {"(G0,';')", "-1.;"},
+  };
+  for (auto const &[format, expect] : negOnes) {
+    ASSERT_TRUE(CompareFormatReal(format, -1.0, expect))
+        << "Failed to format " << format << ", expected " << expect;
+  }
+}
+
+// Each test case contains a raw uint64, a format string for a real value, and
+// the expected resulting string from formatting the raw uint64. The double
+// representation of the uint64 is commented above each test case.
+TEST(IOApiTests, FormatDoubleValues) {
+
+  using TestCaseTy = std::tuple<std::uint64_t,
+      std::vector<std::tuple<const char *, const char *>>>;
+  static const std::vector<TestCaseTy> testCases{
+      {// -0
+          0x8000000000000000,
+          {
+              {"(E9.1,';')", " -0.0E+00;"},
+              {"(F4.0,';')", " -0.;"},
+              {"(G8.0,';')", "-0.0E+00;"},
+              {"(G8.1,';')", " -0.    ;"},
+              {"(G0,';')", "-0.;"},
+              {"(E9.1,';')", " -0.0E+00;"},
+          }},
+      {// +Inf
+          0x7ff0000000000000,
+          {
+              {"(E9.1,';')", "      Inf;"},
+              {"(F9.1,';')", "      Inf;"},
+              {"(G9.1,';')", "      Inf;"},
+              {"(SP,E9.1,';')", "     +Inf;"},
+              {"(SP,F9.1,';')", "     +Inf;"},
+              {"(SP,G9.1,';')", "     +Inf;"},
+              {"(G0,';')", "Inf;"},
+          }},
+      {// -Inf
+          0xfff0000000000000,
+          {
+              {"(E9.1,';')", "     -Inf;"},
+              {"(F9.1,';')", "     -Inf;"},
+              {"(G9.1,';')", "     -Inf;"},
+              {"(G0,';')", "-Inf;"},
+          }},
+      {// NaN
+          0x7ff0000000000001,
+          {
+              {"(E9.1,';')", "      NaN;"},
+              {"(F9.1,';')", "      NaN;"},
+              {"(G9.1,';')", "      NaN;"},
+              {"(G0,';')", "NaN;"},
+          }},
+      {// NaN (sign irrelevant)
+          0xfff0000000000001,
+          {
+              {"(E9.1,';')", "      NaN;"},
+              {"(F9.1,';')", "      NaN;"},
+              {"(G9.1,';')", "      NaN;"},
+              {"(SP,E9.1,';')", "      NaN;"},
+              {"(SP,F9.1,';')", "      NaN;"},
+              {"(SP,G9.1,';')", "      NaN;"},
+              {"(G0,';')", "NaN;"},
+          }},
+      {// 0.1 rounded
+          0x3fb999999999999a,
+          {
+              {"(E62.55,';')",
+                  " 0.1000000000000000055511151231257827021181583404541015625E+"
+                  "00;"},
+              {"(E0.0,';')", "0.E+00;"},
+              {"(E0.55,';')",
+                  "0.1000000000000000055511151231257827021181583404541015625E+"
+                  "00;"},
+              {"(E0,';')", ".1E+00;"},
+              {"(F58.55,';')",
+                  " 0."
+                  "1000000000000000055511151231257827021181583404541015625;"},
+              {"(F0.0,';')", "0.;"},
+              {"(F0.55,';')",
+                  ".1000000000000000055511151231257827021181583404541015625;"},
+              {"(F0,';')", ".1;"},
+              {"(G62.55,';')",
+                  " 0.1000000000000000055511151231257827021181583404541015625  "
+                  "  ;"},
+              {"(G0.0,';')", "0.;"},
+              {"(G0.55,';')",
+                  ".1000000000000000055511151231257827021181583404541015625;"},
+              {"(G0,';')", ".1;"},
+          }},
+      {// 1.5
+          0x3ff8000000000000,
+          {
+              {"(E9.2,';')", " 0.15E+01;"},
+              {"(F4.1,';')", " 1.5;"},
+              {"(G7.1,';')", " 2.    ;"},
+              {"(RN,E8.1,';')", " 0.2E+01;"},
+              {"(RN,F3.0,';')", " 2.;"},
+              {"(RN,G7.0,';')", " 0.E+01;"},
+              {"(RN,G7.1,';')", " 2.    ;"},
+              {"(RD,E8.1,';')", " 0.1E+01;"},
+              {"(RD,F3.0,';')", " 1.;"},
+              {"(RD,G7.0,';')", " 0.E+01;"},
+              {"(RD,G7.1,';')", " 1.    ;"},
+              {"(RU,E8.1,';')", " 0.2E+01;"},
+              {"(RU,G7.0,';')", " 0.E+01;"},
+              {"(RU,G7.1,';')", " 2.    ;"},
+              {"(RZ,E8.1,';')", " 0.1E+01;"},
+              {"(RZ,F3.0,';')", " 1.;"},
+              {"(RZ,G7.0,';')", " 0.E+01;"},
+              {"(RZ,G7.1,';')", " 1.    ;"},
+              {"(RC,E8.1,';')", " 0.2E+01;"},
+              {"(RC,F3.0,';')", " 2.;"},
+              {"(RC,G7.0,';')", " 0.E+01;"},
+              {"(RC,G7.1,';')", " 2.    ;"},
+          }},
+      {// -1.5
+          0xbff8000000000000,
+          {
+              {"(E9.2,';')", "-0.15E+01;"},
+              {"(RN,E8.1,';')", "-0.2E+01;"},
+              {"(RD,E8.1,';')", "-0.2E+01;"},
+              {"(RU,E8.1,';')", "-0.1E+01;"},
+              {"(RZ,E8.1,';')", "-0.1E+01;"},
+              {"(RC,E8.1,';')", "-0.2E+01;"},
+          }},
+      {// 2.5
+          0x4004000000000000,
+          {
+              {"(E9.2,';')", " 0.25E+01;"},
+              {"(RN,E8.1,';')", " 0.2E+01;"},
+              {"(RD,E8.1,';')", " 0.2E+01;"},
+              {"(RU,E8.1,';')", " 0.3E+01;"},
+              {"(RZ,E8.1,';')", " 0.2E+01;"},
+              {"(RC,E8.1,';')", " 0.3E+01;"},
+          }},
+      {// -2.5
+          0xc004000000000000,
+          {
+              {"(E9.2,';')", "-0.25E+01;"},
+              {"(RN,E8.1,';')", "-0.2E+01;"},
+              {"(RD,E8.1,';')", "-0.3E+01;"},
+              {"(RU,E8.1,';')", "-0.2E+01;"},
+              {"(RZ,E8.1,';')", "-0.2E+01;"},
+              {"(RC,E8.1,';')", "-0.3E+01;"},
+          }},
+      {// least positive nonzero subnormal
+          1,
+          {
+              {"(E32.17,';')", "         0.49406564584124654-323;"},
+              {"(ES32.17,';')", "         4.94065645841246544-324;"},
+              {"(EN32.17,';')", "         4.94065645841246544-324;"},
+              {"(E759.752,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "75386825064197182655334472656250-323;"},
+              {"(G0,';')", ".5-323;"},
+              {"(E757.750,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "753868250641971826553344726562-323;"},
+              {"(RN,E757.750,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "753868250641971826553344726562-323;"},
+              {"(RD,E757.750,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "753868250641971826553344726562-323;"},
+              {"(RU,E757.750,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "753868250641971826553344726563-323;"},
+              {"(RC,E757.750,';')",
+                  " 0."
+                  "494065645841246544176568792868221372365059802614324764425585"
+                  "682500675507270208751865299836361635992379796564695445717730"
+                  "926656710355939796398774796010781878126300713190311404527845"
+                  "817167848982103688718636056998730723050006387409153564984387"
+                  "312473397273169615140031715385398074126238565591171026658556"
+                  "686768187039560310624931945271591492455329305456544401127480"
+                  "129709999541931989409080416563324524757147869014726780159355"
+                  "238611550134803526493472019379026810710749170333222684475333"
+                  "572083243193609238289345836806010601150616980975307834227731"
+                  "832924790498252473077637592724787465608477820373446969953364"
+                  "701797267771758512566055119913150489110145103786273816725095"
+                  "583738973359899366480994116420570263709027924276754456522908"
+                  "753868250641971826553344726563-323;"},
+          }},
+      {// least positive nonzero normal
+          0x10000000000000,
+          {
+              {"(E723.716,';')",
+                  " 0."
+                  "222507385850720138309023271733240406421921598046233183055332"
+                  "741688720443481391819585428315901251102056406733973103581100"
+                  "515243416155346010885601238537771882113077799353200233047961"
+                  "014744258363607192156504694250373420837525080665061665815894"
+                  "872049117996859163964850063590877011830487479978088775374994"
+                  "945158045160505091539985658247081864511353793580499211598108"
+                  "576605199243335211435239014879569960959128889160299264151106"
+                  "346631339366347758651302937176204732563178148566435087212282"
+                  "863764204484681140761391147706280168985324411002416144742161"
+                  "856716615054015428508471675290190316132277889672970737312333"
+                  "408698898317506783884692609277397797285865965494109136909540"
+                  "61364675687023986783152906809846172109246253967285156250-"
+                  "307;"},
+              {"(G0,';')", ".22250738585072014-307;"},
+          }},
+      {// greatest finite
+          0x7fefffffffffffffuLL,
+          {
+              {"(E32.17,';')", "         0.17976931348623157+309;"},
+              {"(E317.310,';')",
+                  " 0."
+                  "179769313486231570814527423731704356798070567525844996598917"
+                  "476803157260780028538760589558632766878171540458953514382464"
+                  "234321326889464182768467546703537516986049910576551282076245"
+                  "490090389328944075868508455133942304583236903222948165808559"
+                  "332123348274797826204144723168738177180919299881250404026184"
+                  "1248583680+309;"},
+              {"(ES317.310,';')",
+                  " 1."
+                  "797693134862315708145274237317043567980705675258449965989174"
+                  "768031572607800285387605895586327668781715404589535143824642"
+                  "343213268894641827684675467035375169860499105765512820762454"
+                  "900903893289440758685084551339423045832369032229481658085593"
+                  "321233482747978262041447231687381771809192998812504040261841"
+                  "2485836800+308;"},
+              {"(EN319.310,';')",
+                  " 179."
+                  "769313486231570814527423731704356798070567525844996598917476"
+                  "803157260780028538760589558632766878171540458953514382464234"
+                  "321326889464182768467546703537516986049910576551282076245490"
+                  "090389328944075868508455133942304583236903222948165808559332"
+                  "123348274797826204144723168738177180919299881250404026184124"
+                  "8583680000+306;"},
+              {"(G0,';')", ".17976931348623157+309;"},
+          }},
+  };
+
+  for (auto const &[value, cases] : testCases) {
+    for (auto const &[format, expect] : cases) {
+      ASSERT_TRUE(CompareFormatReal(format, value, expect))
+          << "Failed to format " << format << ", expected " << expect;
+    }
+  }
+
+  using IndividualTestCaseTy = std::tuple<const char *, double, const char *>;
+  static std::vector<IndividualTestCaseTy> individualTestCases{
+      {"(F5.3,';')", 25., "*****;"},
+      {"(F5.3,';')", 2.5, "2.500;"},
+      {"(F5.3,';')", 0.25, "0.250;"},
+      {"(F5.3,';')", 0.025, "0.025;"},
+      {"(F5.3,';')", 0.0025, "0.003;"},
+      {"(F5.3,';')", 0.00025, "0.000;"},
+      {"(F5.3,';')", 0.000025, "0.000;"},
+      {"(F5.3,';')", -25., "*****;"},
+      {"(F5.3,';')", -2.5, "*****;"},
+      {"(F5.3,';')", -0.25, "-.250;"},
+      {"(F5.3,';')", -0.025, "-.025;"},
+      {"(F5.3,';')", -0.0025, "-.003;"},
+      {"(F5.3,';')", -0.00025, "-.000;"},
+      {"(F5.3,';')", -0.000025, "-.000;"},
+  };
+
+  for (auto const &[format, value, expect] : individualTestCases) {
+    ASSERT_TRUE(CompareFormatReal(format, value, expect))
+        << "Failed to format " << format << ", expected " << expect;
+  }
+}
+
+//------------------------------------------------------------------------------
+/// Tests for input formatting real values
+//------------------------------------------------------------------------------
+
+// Ensure double input values correctly map to raw uint64 values
+TEST(IOApiTests, FormatDoubleInputValues) {
+  using TestCaseTy = std::tuple<const char *, const char *, std::uint64_t>;
+  static std::vector<TestCaseTy> testCases{
+      {"(F18.0)", "                 0", 0x0},
+      {"(F18.0)", "                  ", 0x0},
+      {"(F18.0)", "                -0", 0x8000000000000000},
+      {"(F18.0)", "                01", 0x3ff0000000000000},
+      {"(F18.0)", "                 1", 0x3ff0000000000000},
+      {"(F18.0)", "              125.", 0x405f400000000000},
+      {"(F18.0)", "              12.5", 0x4029000000000000},
+      {"(F18.0)", "              1.25", 0x3ff4000000000000},
+      {"(F18.0)", "             01.25", 0x3ff4000000000000},
+      {"(F18.0)", "              .125", 0x3fc0000000000000},
+      {"(F18.0)", "             0.125", 0x3fc0000000000000},
+      {"(F18.0)", "             .0625", 0x3fb0000000000000},
+      {"(F18.0)", "            0.0625", 0x3fb0000000000000},
+      {"(F18.0)", "               125", 0x405f400000000000},
+      {"(F18.1)", "               125", 0x4029000000000000},
+      {"(F18.2)", "               125", 0x3ff4000000000000},
+      {"(F18.3)", "               125", 0x3fc0000000000000},
+      {"(-1P,F18.0)", "               125", 0x4093880000000000}, // 1250
+      {"(1P,F18.0)", "               125", 0x4029000000000000}, // 12.5
+      {"(BZ,F18.0)", "              125 ", 0x4093880000000000}, // 1250
+      {"(BZ,F18.0)", "       125 . e +1 ", 0x42a6bcc41e900000}, // 1.25e13
+      {"(DC,F18.0)", "              12,5", 0x4029000000000000},
+  };
+  for (auto const &[format, data, want] : testCases) {
+    auto *cookie{IONAME(BeginInternalFormattedInput)(
+        data, std::strlen(data), format, std::strlen(format))};
+    union {
+      double x;
+      std::uint64_t raw;
+    } u;
+    u.raw = 0;
+
+    // Read buffer into union value
+    IONAME(EnableHandlers)(cookie, true, true, true, true, true);
+    IONAME(InputReal64)(cookie, u.x);
+
+    static constexpr int bufferSize{65};
+    static char iomsg[bufferSize];
+    std::memset(iomsg, '\0', bufferSize - 1);
+
+    // Ensure no errors were encountered reading input buffer into union value
+    IONAME(GetIoMsg)(cookie, iomsg, bufferSize - 1);
+    static auto status{IONAME(EndIoStatement)(cookie)};
+    ASSERT_EQ(status, 0) << '\'' << format << "' failed reading '" << data
+                         << "', status " << static_cast<int>(status)
+                         << " iomsg '" << iomsg << "'";
+
+    // Ensure raw uint64 value matches expected conversion from double
+    ASSERT_EQ(u.raw, want) << '\'' << format << "' failed reading '" << data
+                           << "', want 0x" << std::hex << want << ", got 0x"
+                           << u.raw;
+  }
+}