Peter Klausler 35cabd69e6
[flang] Support fixed-width input field truncation for LOGICAL (#151203)
As a common extension, we support the truncation of fixed-width fields
for non-list-directed input editing when a separator character (',' or
';' depending on DECIMAL='POINT' or 'COMMA' resp.) appears in the field.
This isn't working for L input editing; fix.

(The bug reports a failure with DC mode, but it doesn't work with a
comma either.)

Fixes https://github.com/llvm/llvm-project/issues/151178.
2025-07-30 11:42:14 -07:00

107 lines
3.6 KiB
C++

//===-- unittests/Runtime/InputExtensions.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 "flang-rt/runtime/descriptor.h"
#include "flang/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;
struct InputExtensionTests : CrashHandlerFixture {};
TEST(InputExtensionTests, SeparatorInField_F) {
static const struct {
int get;
const char *format, *data;
double expect[3];
} test[] = {
{2, "(2F6)", "1.25,3.75,", {1.25, 3.75}},
{2, "(2F6)", "1.25 ,3.75 ,", {1.25, 3.75}},
{2, "(DC,2F6)", "1,25;3,75;", {1.25, 3.75}},
{2, "(DC,2F6)", "1,25 ;3,75 ;", {1.25, 3.75}},
};
for (std::size_t j{0}; j < sizeof test / sizeof *test; ++j) {
auto cookie{IONAME(BeginInternalFormattedInput)(test[j].data,
std::strlen(test[j].data), test[j].format,
std::strlen(test[j].format))};
for (int k{0}; k < test[j].get; ++k) {
float got;
IONAME(InputReal32)(cookie, got);
ASSERT_EQ(got, test[j].expect[k])
<< "expected " << test[j].expect[k] << ", got " << got;
}
auto status{IONAME(EndIoStatement)(cookie)};
ASSERT_EQ(status, 0) << "error status " << status << " on F test case "
<< j;
}
}
TEST(InputExtensionTests, SeparatorInField_I) {
static const struct {
int get;
const char *format, *data;
std::int64_t expect[3];
} test[] = {
{2, "(2I4)", "12,34,", {12, 34}},
{2, "(2I4)", "12 ,34 ,", {12, 34}},
{2, "(DC,2I4)", "12;34;", {12, 34}},
{2, "(DC,2I4)", "12 ;34 ;", {12, 34}},
};
for (std::size_t j{0}; j < sizeof test / sizeof *test; ++j) {
auto cookie{IONAME(BeginInternalFormattedInput)(test[j].data,
std::strlen(test[j].data), test[j].format,
std::strlen(test[j].format))};
for (int k{0}; k < test[j].get; ++k) {
std::int64_t got;
IONAME(InputInteger)(cookie, got);
ASSERT_EQ(got, test[j].expect[k])
<< "expected " << test[j].expect[k] << ", got " << got;
}
auto status{IONAME(EndIoStatement)(cookie)};
ASSERT_EQ(status, 0) << "error status " << status << " on I test case "
<< j;
}
}
TEST(InputExtensionTests, SeparatorInField_L) {
static const struct {
int get;
const char *format, *data;
bool expect[3];
} test[] = {
{2, "(2L4)", ".T,F,", {true, false}},
{2, "(2L4)", ".F,T,", {false, true}},
{2, "(2L4)", ".T.,F,", {true, false}},
{2, "(2L4)", ".F.,T,", {false, true}},
{2, "(DC,2L4)", ".T;F,", {true, false}},
{2, "(DC,2L4)", ".F;T,", {false, true}},
{2, "(DC,2L4)", ".T.;F,", {true, false}},
{2, "(DC,2L4)", ".F.;T,", {false, true}},
};
for (std::size_t j{0}; j < sizeof test / sizeof *test; ++j) {
auto cookie{IONAME(BeginInternalFormattedInput)(test[j].data,
std::strlen(test[j].data), test[j].format,
std::strlen(test[j].format))};
for (int k{0}; k < test[j].get; ++k) {
bool got;
IONAME(InputLogical)(cookie, got);
ASSERT_EQ(got, test[j].expect[k])
<< "expected " << test[j].expect[k] << ", got " << got;
}
auto status{IONAME(EndIoStatement)(cookie)};
ASSERT_EQ(status, 0) << "error status " << status << " on L test case "
<< j;
}
}