[flang] Implement READ(SIZE=) and INQUIRE(IOLENGTH=) in runtime

[klausler]

Summary

Count input characters corresponding to formatted edit descriptors
for READ(SIZE=); count output bytes for INQUIRE(IOLENGTH=).

The I/O APIs GetSize() and GetLength() were adjusted to return
std::size_t as function results.

Basic unit tests were added (and others fixed).

flang/include/flang/Runtime/io-api.h

 bool IONAME(SetStatus)(Cookie, const char *, std::size_t);
 
 bool IONAME(SetFile)(Cookie, const char *, std::size_t chars);
 
 // Acquires the runtime-created unit number for OPEN(NEWUNIT=)
 bool IONAME(GetNewUnit)(Cookie, int &, int kind = 4);
 
 // READ(SIZE=), after all input items
-bool IONAME(GetSize)(Cookie, std::int64_t, int kind = 8);
+std::size_t IONAME(GetSize)(Cookie);
 
 // INQUIRE(IOLENGTH=), after all output items
-bool IONAME(GetIoLength)(Cookie, std::int64_t, int kind = 8);
+std::size_t IONAME(GetIoLength)(Cookie);
 
 // GetIoMsg() does not modify its argument unless an error or
 // end-of-record/file condition is present.
 void IONAME(GetIoMsg)(Cookie, char *, std::size_t); // IOMSG=
 
 // INQUIRE() specifiers are mostly identified by their NUL-terminated
 // case-insensitive names.
 // ACCESS, ACTION, ASYNCHRONOUS, BLANK, CONVERT, DECIMAL, DELIM, DIRECT,

flang/runtime/descriptor-io.h

if (const typeInfo::SpecialBinding *
                         : typeInfo::SpecialBinding::Which::WriteUnformatted)
               : nullptr}) {
     // User-defined derived type unformatted I/O
     return DefinedUnformattedIo(io, descriptor, *special);
   } else {
     // Regular derived type unformatted I/O, not user-defined
     auto *externalUnf{io.get_if<ExternalUnformattedIoStatementState<DIR>>()};
     auto *childUnf{io.get_if<ChildUnformattedIoStatementState<DIR>>()};
-    RUNTIME_CHECK(handler, externalUnf != nullptr || childUnf != nullptr);
+    auto *inq{
+        DIR == Direction::Output ? io.get_if<InquireIOLengthState>() : nullptr};
+    RUNTIME_CHECK(handler, externalUnf || childUnf || inq);
     std::size_t elementBytes{descriptor.ElementBytes()};
     std::size_t numElements{descriptor.Elements()};
     SubscriptValue subscripts[maxRank];
     descriptor.GetLowerBounds(subscripts);
     using CharType =
         std::conditional_t<DIR == Direction::Output, const char, char>;
     auto Transfer{[=](CharType &x, std::size_t totalBytes,
                       std::size_t elementBytes) -> bool {
       if constexpr (DIR == Direction::Output) {
         return externalUnf ? externalUnf->Emit(&x, totalBytes, elementBytes)
-                           : childUnf->Emit(&x, totalBytes, elementBytes);
+            : childUnf     ? childUnf->Emit(&x, totalBytes, elementBytes)
+                           : inq->Emit(&x, totalBytes, elementBytes);
       } else {
         return externalUnf ? externalUnf->Receive(&x, totalBytes, elementBytes)
                            : childUnf->Receive(&x, totalBytes, elementBytes);
       }
     }};
     if (descriptor.IsContiguous()) { // contiguous unformatted I/O
       char &x{ExtractElement<char>(io, descriptor, subscripts)};
       return Transfer(x, numElements * elementBytes, elementBytes);
io.GetIoErrorHandler().Crash(
         "DescriptorIO() called for wrong I/O direction");
     return false;
   }
   if constexpr (DIR == Direction::Input) {
     if (!io.BeginReadingRecord()) {
       return false;
     }
   }
-  if (!io.get_if<FormattedIoStatementState>()) {
+  if (!io.get_if<FormattedIoStatementState<DIR>>()) {
     return UnformattedDescriptorIO<DIR>(io, descriptor);
   }
   IoErrorHandler &handler{io.GetIoErrorHandler()};
   if (auto catAndKind{descriptor.type().GetCategoryAndKind()}) {
     TypeCategory cat{catAndKind->first};
     int kind{catAndKind->second};
     switch (cat) {
     case TypeCategory::Integer:

flang/runtime/edit-input.cpp

 // Returns true if there's a '-' sign.
 static bool ScanNumericPrefix(IoStatementState &io, const DataEdit &edit,
     std::optional<char32_t> &next, std::optional<int> &remaining) {
   next = io.PrepareInput(edit, remaining);
   bool negative{false};
   if (next) {
     negative = *next == '-';
     if (negative || *next == '+') {
+      io.GotChar();
       io.SkipSpaces(remaining);
       next = io.NextInField(remaining);
     }
   }
   return negative;
 }
 
 bool EditIntegerInput(
bool EditDefaultCharacterInput(
   // When the field is wider than the variable, we drop the leading
   // characters.  When the variable is wider than the field, there's
   // trailing padding.
   std::int64_t skip{*remaining - static_cast<std::int64_t>(length)};
   for (std::optional<char32_t> next{io.NextInField(remaining)}; next;
        next = io.NextInField(remaining)) {
     if (skip > 0) {
       --skip;
+      io.GotChar(-1);
     } else {
       *x++ = *next;
       --length;
     }
   }
   std::fill_n(x, length, ' ');
   return true;
 }

flang/runtime/io-api.cpp

 }
 
 bool IONAME(OutputUnformattedBlock)(Cookie cookie, const char *x,
     std::size_t length, std::size_t elementBytes) {
   IoStatementState &io{*cookie};
   if (auto *unf{io.get_if<
           ExternalUnformattedIoStatementState<Direction::Output>>()}) {
     return unf->Emit(x, length, elementBytes);
+  } else if (auto *inq{io.get_if<InquireIOLengthState>()}) {
+    return inq->Emit(x, length, elementBytes);
   }
   io.GetIoErrorHandler().Crash("OutputUnformattedBlock() called for an I/O "
                                "statement that is not unformatted output");
   return false;
 }
 
 bool IONAME(InputUnformattedBlock)(
     Cookie cookie, char *x, std::size_t length, std::size_t elementBytes) {
bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
   cookie->CheckFormattedStmtType<Direction::Input>("InputLogical");
   StaticDescriptor staticDescriptor;
   Descriptor &descriptor{staticDescriptor.descriptor()};
   descriptor.Establish(
       TypeCategory::Logical, sizeof truth, reinterpret_cast<void *>(&truth), 0);
   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
 }
 
+std::size_t IONAME(GetSize)(Cookie cookie) {
+  IoStatementState &io{*cookie};
+  if (const auto *formatted{
+          io.get_if<FormattedIoStatementState<Direction::Input>>()}) {
+    return formatted->GetEditDescriptorChars();
+  }
+  io.GetIoErrorHandler().Crash(
+      "GetIoSize() called for an I/O statement that is not a formatted READ()");
+  return 0;
+}
+
+std::size_t IONAME(GetIoLength)(Cookie cookie) {
+  IoStatementState &io{*cookie};
+  if (const auto *inq{io.get_if<InquireIOLengthState>()}) {
+    return inq->bytes();
+  }
+  io.GetIoErrorHandler().Crash("GetIoLength() called for an I/O statement that "
+                               "is not INQUIRE(IOLENGTH=)");
+  return 0;
+}
+
 void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
   if (handler.InError()) { // leave "msg" alone when no error
     handler.GetIoMsg(msg, length);
   }
 }
 
 bool IONAME(InquireCharacter)(Cookie cookie, InquiryKeywordHash inquiry,

flang/runtime/io-stmt.h

 template <Direction> class ChildListIoStatementState;
 template <Direction> class ChildUnformattedIoStatementState;
 
 struct InputStatementState {};
 struct OutputStatementState {};
 template <Direction D>
 using IoDirectionState = std::conditional_t<D == Direction::Input,
     InputStatementState, OutputStatementState>;
-struct FormattedIoStatementState {};
+
+// Common state for all kinds of formatted I/O
+template <Direction D> class FormattedIoStatementState {};
+template <> class FormattedIoStatementState<Direction::Input> {
+public:
+  std::size_t GetEditDescriptorChars() const;
+  void GotChar(int);
+
+private:
+  // Account of characters read for edit descriptors (i.e., formatted I/O
+  // with a FORMAT, not list-directed or NAMELIST), not including padding.
+  std::size_t chars_{0}; // for READ(SIZE=)
+};
 
 // The Cookie type in the I/O API is a pointer (for C) to this class.
 class IoStatementState {
 public:
   template <typename A> explicit IoStatementState(A &x) : u_{x} {}
 
   // These member functions each project themselves into the active alternative.
   // They're used by per-data-item routines in the I/O API (e.g., OutputReal64)
public:
   std::optional<DataEdit> GetNextDataEdit(int = 1);
   ExternalFileUnit *GetExternalFileUnit() const; // null if internal unit
   bool BeginReadingRecord();
   void FinishReadingRecord();
   bool Inquire(InquiryKeywordHash, char *, std::size_t);
   bool Inquire(InquiryKeywordHash, bool &);
   bool Inquire(InquiryKeywordHash, std::int64_t, bool &); // PENDING=
   bool Inquire(InquiryKeywordHash, std::int64_t &);
+  void GotChar(signed int = 1); // for READ(SIZE=); can be <0
 
   MutableModes &mutableModes();
   ConnectionState &GetConnectionState();
   IoErrorHandler &GetIoErrorHandler() const;
 
   // N.B.: this also works with base classes
   template <typename A> A *get_if() const {
     return std::visit(
std::optional<char32_t> PrepareInput(
       const DataEdit &edit, std::optional<int> &remaining);
 
   std::optional<char32_t> SkipSpaces(std::optional<int> &remaining);
   std::optional<char32_t> NextInField(std::optional<int> &remaining);
   // Skips spaces, advances records, and ignores NAMELIST comments
   std::optional<char32_t> GetNextNonBlank();
 
   template <Direction D> void CheckFormattedStmtType(const char *name) {
-    if (!get_if<FormattedIoStatementState>() ||
-        !get_if<IoDirectionState<D>>()) {
+    if (!get_if<FormattedIoStatementState<D>>()) {
       GetIoErrorHandler().Crash(
           "%s called for I/O statement that is not formatted %s", name,
           D == Direction::Output ? "output" : "input");
     }
   }
 
 private:
   std::variant<std::reference_wrapper<OpenStatementState>,
struct IoStatementBase : public IoErrorHandler {
 
   void BadInquiryKeywordHashCrash(InquiryKeywordHash);
 };
 
 // Common state for list-directed & NAMELIST I/O, both internal & external
 template <Direction> class ListDirectedStatementState;
 template <>
 class ListDirectedStatementState<Direction::Output>
-    : public FormattedIoStatementState {
+    : public FormattedIoStatementState<Direction::Output> {
 public:
   bool EmitLeadingSpaceOrAdvance(
       IoStatementState &, std::size_t = 1, bool isCharacter = false);
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1);
   bool lastWasUndelimitedCharacter() const {
     return lastWasUndelimitedCharacter_;
   }
   void set_lastWasUndelimitedCharacter(bool yes = true) {
     lastWasUndelimitedCharacter_ = yes;
   }
 
 private:
   bool lastWasUndelimitedCharacter_{false};
 };
 template <>
 class ListDirectedStatementState<Direction::Input>
-    : public FormattedIoStatementState {
+    : public FormattedIoStatementState<Direction::Input> {
 public:
   // Skips value separators, handles repetition and null values.
   // Vacant when '/' appears; present with descriptor == ListDirectedNullValue
   // when a null value appears.
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1);
 
   // Each NAMELIST input item is a distinct "list-directed"

 protected:
   bool free_{true};
   InternalDescriptorUnit<DIR> unit_;
 };
 
 template <Direction DIR, typename CHAR>
 class InternalFormattedIoStatementState
     : public InternalIoStatementState<DIR, CHAR>,
-      public FormattedIoStatementState {
+      public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   using typename InternalIoStatementState<DIR, CharType>::Buffer;
   InternalFormattedIoStatementState(Buffer internal, std::size_t internalLength,
       const CharType *format, std::size_t formatLength,
       const char *sourceFile = nullptr, int sourceLine = 0);
   InternalFormattedIoStatementState(const Descriptor &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,

 private:
   // These are forked from ConnectionState's modes at the beginning
   // of each formatted I/O statement so they may be overridden by control
   // edit descriptors during the statement.
   MutableModes mutableModes_;
 };
 
 template <Direction DIR, typename CHAR>
-class ExternalFormattedIoStatementState : public ExternalIoStatementState<DIR>,
-                                          public FormattedIoStatementState {
+class ExternalFormattedIoStatementState
+    : public ExternalIoStatementState<DIR>,
+      public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ExternalFormattedIoStatementState(ExternalFileUnit &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
   int EndIoStatement();
   std::optional<DataEdit> GetNextDataEdit(
       IoStatementState &, int maxRepeat = 1) {
public:
   void HandleAbsolutePosition(std::int64_t);
 
 private:
   ChildIo &child_;
 };
 
 template <Direction DIR, typename CHAR>
 class ChildFormattedIoStatementState : public ChildIoStatementState<DIR>,
-                                       public FormattedIoStatementState {
+                                       public FormattedIoStatementState<DIR> {
 public:
   using CharType = CHAR;
   ChildFormattedIoStatementState(ChildIo &, const CharType *format,
       std::size_t formatLength, const char *sourceFile = nullptr,
       int sourceLine = 0);
   MutableModes &mutableModes() { return mutableModes_; }
   int EndIoStatement();
   bool AdvanceRecord(int = 1);
private:
   OwningPtr<char> path_; // trimmed and NUL terminated
 };
 
 class InquireIOLengthState : public NoUnitIoStatementState,
                              public OutputStatementState {
 public:
   InquireIOLengthState(const char *sourceFile = nullptr, int sourceLine = 0);
   std::size_t bytes() const { return bytes_; }
+  bool Emit(const char *, std::size_t, std::size_t elementBytes);
+  bool Emit(const char *, std::size_t);
+  bool Emit(const char16_t *, std::size_t chars);
+  bool Emit(const char32_t *, std::size_t chars);
 
 private:
   std::size_t bytes_{0};
 };
 
 class ExternalMiscIoStatementState : public ExternalIoStatementBase {
 public:
   enum Which { Flush, Backspace, Endfile, Rewind };

flang/runtime/io-stmt.cpp

std::optional<char32_t> IoStatementState::SkipSpaces(
     std::optional<int> &remaining) {
   while (!remaining || *remaining > 0) {
     if (auto ch{GetCurrentChar()}) {
       if (*ch != ' ' && *ch != '\t') {
         return ch;
       }
       HandleRelativePosition(1);
       if (remaining) {
+        GotChar();
         --*remaining;
       }
     } else {
       break;
     }
   }
   return std::nullopt;
 }
if (auto next{GetCurrentChar()}) {
         HandleRelativePosition(1);
         return next;
       }
     }
   } else if (*remaining > 0) {
     if (auto next{GetCurrentChar()}) {
       --*remaining;
       HandleRelativePosition(1);
+      GotChar();
       return next;
     }
     const ConnectionState &connection{GetConnectionState()};
     if (!connection.IsAtEOF() && connection.recordLength &&
         connection.positionInRecord >= *connection.recordLength) {
       IoErrorHandler &handler{GetIoErrorHandler()};
       if (mutableModes().nonAdvancing) {
         handler.SignalEor();
bool IoStatementState::Inquire(
   return std::visit(
       [&](auto &x) { return x.get().Inquire(inquiry, id, out); }, u_);
 }
 
 bool IoStatementState::Inquire(InquiryKeywordHash inquiry, std::int64_t &n) {
   return std::visit([&](auto &x) { return x.get().Inquire(inquiry, n); }, u_);
 }
 
+void IoStatementState::GotChar(int n) {
+  if (auto *formattedIn{
+          get_if<FormattedIoStatementState<Direction::Input>>()}) {
+    formattedIn->GotChar(n);
+  } else {
+    GetIoErrorHandler().Crash("IoStatementState::GotChar() called for "
+                              "statement that is not formatted input");
+  }
+}
+
+std::size_t
+FormattedIoStatementState<Direction::Input>::GetEditDescriptorChars() const {
+  return chars_;
+}
+
+void FormattedIoStatementState<Direction::Input>::GotChar(int n) {
+  chars_ += n;
+}
+
 bool ListDirectedStatementState<Direction::Output>::EmitLeadingSpaceOrAdvance(
     IoStatementState &io, std::size_t length, bool isCharacter) {
   if (length == 0) {
     return true;
   }
   const ConnectionState &connection{io.GetConnectionState()};
   int space{connection.positionInRecord == 0 ||
       !(isCharacter && lastWasUndelimitedCharacter())};
default:
     return false;
   }
 }
 
 InquireIOLengthState::InquireIOLengthState(
     const char *sourceFile, int sourceLine)
     : NoUnitIoStatementState{sourceFile, sourceLine, *this} {}
 
+bool InquireIOLengthState::Emit(
+    const char *, std::size_t n, std::size_t elementBytes) {
+  bytes_ += n * elementBytes;
+  return true;
+}
+
+bool InquireIOLengthState::Emit(const char *p, std::size_t n) {
+  bytes_ += sizeof *p * n;
+  return true;
+}
+
+bool InquireIOLengthState::Emit(const char16_t *p, std::size_t n) {
+  bytes_ += sizeof *p * n;
+  return true;
+}
+
+bool InquireIOLengthState::Emit(const char32_t *p, std::size_t n) {
+  bytes_ += sizeof *p * n;
+  return true;
+}
+
 } // namespace Fortran::runtime::io

flang/runtime/unit.cpp

 
 void ChildIo::EndIoStatement() {
   io_.reset();
   u_.emplace<std::monostate>();
 }
 
 bool ChildIo::CheckFormattingAndDirection(Terminator &terminator,
     const char *what, bool unformatted, Direction direction) {
-  bool parentIsUnformatted{!parent_.get_if<FormattedIoStatementState>()};
   bool parentIsInput{!parent_.get_if<IoDirectionState<Direction::Output>>()};
+  bool parentIsFormatted{parentIsInput
+          ? parent_.get_if<FormattedIoStatementState<Direction::Input>>() !=
+              nullptr
+          : parent_.get_if<FormattedIoStatementState<Direction::Output>>() !=
+              nullptr};
+  bool parentIsUnformatted{!parentIsFormatted};
   if (unformatted != parentIsUnformatted) {
     terminator.Crash("Child %s attempted on %s parent I/O unit", what,
         parentIsUnformatted ? "unformatted" : "formatted");
     return false;
   } else if (parentIsInput != (direction == Direction::Input)) {
     terminator.Crash("Child %s attempted on %s parent I/O unit", what,
         parentIsInput ? "input" : "output");
     return false;
   } else {
     return true;
   }
 }
 
 } // namespace Fortran::runtime::io

flang/unittests/Runtime/ExternalIOTest.cpp

TEST(ExternalIOTests, TestDirectUnformatted) {
   ASSERT_TRUE(IONAME(SetRecl)(io, recl)) << "SetRecl()";
   ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
 
   int unit{-1};
   ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OpenNewUnit";
 
+  // INQUIRE(IOLENGTH=) j
+  io = IONAME(BeginInquireIoLength)(__FILE__, __LINE__);
+  ASSERT_TRUE(IONAME(OutputUnformattedBlock)(
+      io, reinterpret_cast<const char *>(&buffer), 1, recl))
+      << "OutputUnformattedBlock() for InquireIoLength";
+  ASSERT_EQ(IONAME(GetIoLength)(io), recl) << "GetIoLength";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for InquireIoLength";
+
   static constexpr int records{10};
   for (int j{1}; j <= records; ++j) {
     // WRITE(UNIT=unit,REC=j) j
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(SetRec)(io, j)) << "SetRec(" << j << ')';
 
     buffer = j;
     ASSERT_TRUE(IONAME(OutputUnformattedBlock)(
-        io, reinterpret_cast<const char *>(&buffer), recl, recl))
+        io, reinterpret_cast<const char *>(&buffer), 1, recl))
         << "OutputUnformattedBlock()";
 
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for OutputUnformattedBlock";
   }
 
   for (int j{records}; j >= 1; --j) {
     // READ(UNIT=unit,REC=j) n
     io = IONAME(BeginUnformattedInput)(unit, __FILE__, __LINE__);
     ASSERT_TRUE(IONAME(SetRec)(io, j)) << "SetRec(" << j << ')';
     ASSERT_TRUE(IONAME(InputUnformattedBlock)(
-        io, reinterpret_cast<char *>(&buffer), recl, recl))
+        io, reinterpret_cast<char *>(&buffer), 1, recl))
         << "InputUnformattedBlock()";
 
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for InputUnformattedBlock";
 
     ASSERT_EQ(buffer, j) << "Read back " << buffer
                          << " from direct unformatted record " << j
                          << ", expected " << j << '\n';
TEST(ExternalIOTests, TestSequentialFixedUnformatted) {
   ASSERT_TRUE(IONAME(SetRecl)(io, recl)) << "SetRecl()";
   ASSERT_TRUE(IONAME(SetStatus)(io, "SCRATCH", 7)) << "SetStatus(SCRATCH)";
 
   int unit{-1};
   ASSERT_TRUE(IONAME(GetNewUnit)(io, unit)) << "GetNewUnit()";
   ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
       << "EndIoStatement() for OpenNewUnit";
 
+  // INQUIRE(IOLENGTH=) j, ...
+  io = IONAME(BeginInquireIoLength)(__FILE__, __LINE__);
+  for (int j{1}; j <= 3; ++j) {
+    ASSERT_TRUE(IONAME(OutputUnformattedBlock)(
+        io, reinterpret_cast<const char *>(&buffer), 1, recl))
+        << "OutputUnformattedBlock() for InquireIoLength";
+  }
+  ASSERT_EQ(IONAME(GetIoLength)(io), 3 * recl) << "GetIoLength";
+  ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
+      << "EndIoStatement() for InquireIoLength";
+
   static const int records{10};
   for (int j{1}; j <= records; ++j) {
     // DO J=1,RECORDS; WRITE(UNIT=unit) j; END DO
     io = IONAME(BeginUnformattedOutput)(unit, __FILE__, __LINE__);
     buffer = j;
     ASSERT_TRUE(IONAME(OutputUnformattedBlock)(
         io, reinterpret_cast<const char *>(&buffer), recl, recl))
         << "OutputUnformattedBlock()";
TEST(ExternalIOTests, TestSequentialVariableFormatted) {
 
   for (int j{records}; j >= 1; --j) {
     // BACKSPACE(unit)
     io = IONAME(BeginBackspace)(unit, __FILE__, __LINE__);
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for Backspace (before read)";
 
     std::snprintf(fmt, sizeof fmt, "(%dI4)", j);
-    // READ(UNIT=unit,FMT=fmt) n; check
+    // READ(UNIT=unit,FMT=fmt,SIZE=chars) n; check
     io = IONAME(BeginExternalFormattedInput)(
         fmt, std::strlen(fmt), unit, __FILE__, __LINE__);
 
     std::int64_t check[records];
     for (int k{0}; k < j; ++k) {
       ASSERT_TRUE(IONAME(InputInteger)(io, check[k])) << "InputInteger()";
     }
 
+    std::size_t chars{IONAME(GetSize)(io)};
+    ASSERT_EQ(chars, j * 4u)
+        << "GetSize()=" << chars << ", expected " << (j * 4u) << '\n';
     ASSERT_EQ(IONAME(EndIoStatement)(io), IostatOk)
         << "EndIoStatement() for InputInteger";
     for (int k{0}; k < j; ++k) {
       ASSERT_EQ(buffer[k], check[k])
           << "Read back [" << k << "]=" << buffer[k]
           << " from sequential variable formatted record " << j << ", expected "
           << buffer[k] << '\n';
     }