[flang] Change capitalization for Adjustl/r

[rovka]

Summary

Rename the definitions of the character runtime functions Adjustl and
Adjustr (used to be AdjustL and AdjustR respectively, which didn't match
the declarations).

Also add unit tests (and move some of the helpers to the top of the
file, since they're now used in more than one place).

[klausler]

The names in the API are the right ones.

[rovka]

Right, I wasn't sure so I just picked the one that seemed to look more like the rest of the runtime :) Is there a convention somewhere, or is it just that once we committed something to the header we shouldn't change it? In any case, I updated the patch, hope it looks better now.

[klausler]

LGTM; thanks!

flang/runtime/character.h

 std::size_t RTNAME(CharacterAppend1)(char *lhs, std::size_t lhsBytes,
     std::size_t offset, const char *rhs, std::size_t rhsBytes);
 
 // Appends any necessary spaces to a CHARACTER(KIND=1) scalar.
 void RTNAME(CharacterPad1)(char *lhs, std::size_t bytes, std::size_t offset);
 
 // Intrinsic functions
 // The result descriptors below are all established by the runtime.
-void RTNAME(Adjustl)(Descriptor &result, const Descriptor &,
+void RTNAME(AdjustL)(Descriptor &result, const Descriptor &,
     const char *sourceFile = nullptr, int sourceLine = 0);
-void RTNAME(Adjustr)(Descriptor &result, const Descriptor &,
+void RTNAME(AdjustR)(Descriptor &result, const Descriptor &,
     const char *sourceFile = nullptr, int sourceLine = 0);
 std::size_t RTNAME(LenTrim1)(const char *, std::size_t);
 std::size_t RTNAME(LenTrim2)(const char16_t *, std::size_t);
 std::size_t RTNAME(LenTrim4)(const char32_t *, std::size_t);
 void RTNAME(LenTrim)(Descriptor &result, const Descriptor &, int kind,
     const char *sourceFile = nullptr, int sourceLine = 0);
 void RTNAME(Repeat)(Descriptor &result, const Descriptor &string,
     std::size_t ncopies, const char *sourceFile = nullptr, int sourceLine = 0);

flang/unittests/RuntimeGTest/CharacterTest.cpp

 #include "gtest/gtest.h"
 #include <cstring>
 #include <functional>
 #include <tuple>
 #include <vector>
 
 using namespace Fortran::runtime;
 
+using CharacterTypes = ::testing::Types<char, char16_t, char32_t>;
+
+// Helper for creating, allocating and filling up a descriptor with data from
+// raw character literals, converted to the CHAR type used by the test.
+template <typename CHAR>
+OwningPtr<Descriptor> CreateDescriptor(const std::vector<SubscriptValue> &shape,
+    const std::vector<const char *> &raw_strings) {
+  std::size_t length{std::strlen(raw_strings[0])};
+
+  OwningPtr<Descriptor> descriptor{Descriptor::Create(sizeof(CHAR), length,
+      nullptr, shape.size(), nullptr, CFI_attribute_allocatable)};
+  if ((shape.empty() ? descriptor->Allocate()
+                     : descriptor->Allocate(
+                           std::vector<SubscriptValue>(shape.size(), 1).data(),
+                           shape.data())) != 0) {
+    return nullptr;
+  }
+
+  std::size_t offset = 0;
+  for (const char *raw : raw_strings) {
+    std::basic_string<CHAR> converted{raw, raw + length};
+    std::copy(converted.begin(), converted.end(),
+        descriptor->OffsetElement<CHAR>(offset * length * sizeof(CHAR)));
+    ++offset;
+  }
+
+  return descriptor;
+}
+
 TEST(CharacterTests, AppendAndPad) {
   static constexpr int limitMax{8};
   static char buffer[limitMax];
   static std::size_t offset{0};
   for (std::size_t limit{0}; limit < limitMax; ++limit, offset = 0) {
     std::memset(buffer, 0, sizeof buffer);
 
     // Ensure appending characters does not overrun the limit
TEST(CharacterTests, CharacterAppend1Overrun) {
   static char buffer[bufferSize];
   static std::size_t offset{0};
   std::memset(buffer, 0, sizeof buffer);
   offset = RTNAME(CharacterAppend1)(buffer, limit, offset, "1234", bufferSize);
   ASSERT_EQ(offset, limit) << "CharacterAppend1 did not halt at limit = "
                            << limit << ", but at offset = " << offset;
 }
 
+template <typename CHAR> struct AdjustLRTests : public ::testing::Test {};
+TYPED_TEST_SUITE(AdjustLRTests, CharacterTypes, );
+
+struct AdjustLRTestCase {
+  const char *input, *output;
+};
+
+template <typename CHAR>
+void RunAdjustLRTest(const char *which,
+    const std::function<void(
+        Descriptor &, const Descriptor &, const char *, int)> &adjust,
+    const char *inputRaw, const char *outputRaw) {
+  OwningPtr<Descriptor> input{CreateDescriptor<CHAR>({}, {inputRaw})};
+  ASSERT_NE(input, nullptr);
+  ASSERT_TRUE(input->IsAllocated());
+
+  StaticDescriptor<1> outputStaticDescriptor;
+  Descriptor &output{outputStaticDescriptor.descriptor()};
+
+  adjust(output, *input, nullptr, 0);
+  std::basic_string<CHAR> got{
+      output.OffsetElement<CHAR>(), std::strlen(inputRaw)};
+  std::basic_string<CHAR> expect{outputRaw, outputRaw + std::strlen(outputRaw)};
+  ASSERT_EQ(got, expect) << which << "('" << inputRaw
+                         << "') for CHARACTER(kind=" << sizeof(CHAR) << ")";
+}
+
+TYPED_TEST(AdjustLRTests, AdjustL) {
+  static std::vector<AdjustLRTestCase> testcases{
+      {"     where should the spaces be?", "where should the spaces be?     "},
+      {"   leading and trailing whitespaces   ",
+          "leading and trailing whitespaces      "},
+      {"shouldn't change", "shouldn't change"},
+  };
+
+  for (const auto &t : testcases) {
+    RunAdjustLRTest<TypeParam>("AdjustL", RTNAME(AdjustL), t.input, t.output);
+  }
+}
+
+TYPED_TEST(AdjustLRTests, AdjustR) {
+  static std::vector<AdjustLRTestCase> testcases{
+      {"where should the spaces be?   ", "   where should the spaces be?"},
+      {" leading and trailing whitespaces ",
+          "  leading and trailing whitespaces"},
+      {"shouldn't change", "shouldn't change"},
+  };
+
+  for (const auto &t : testcases) {
+    RunAdjustLRTest<TypeParam>("AdjustR", RTNAME(AdjustR), t.input, t.output);
+  }
+}
+
 //------------------------------------------------------------------------------
 /// Tests and infrastructure for character comparison functions
 //------------------------------------------------------------------------------
 
 template <typename CHAR>
 using ComparisonFuncTy =
     std::function<int(const CHAR *, const CHAR *, std::size_t, std::size_t)>;
 
struct CharacterComparisonTests : public ::testing::Test {
   CharacterComparisonTests()
       : parameters{std::get<ComparisonParametersTy<CHAR>>(comparisonTestCases)},
         characterComparisonFunc{
             std::get<ComparisonFuncTy<CHAR>>(comparisonFuncs)} {}
   ComparisonParametersTy<CHAR> parameters;
   ComparisonFuncTy<CHAR> characterComparisonFunc;
 };
 
-using CharacterTypes = ::testing::Types<char, char16_t, char32_t>;
 TYPED_TEST_SUITE(CharacterComparisonTests, CharacterTypes, );
 
 TYPED_TEST(CharacterComparisonTests, CompareCharacters) {
   for (auto &[x, y, xBytes, yBytes, expect] : this->parameters) {
     int cmp{this->characterComparisonFunc(x, y, xBytes, yBytes)};
     TypeParam buf[2][8];
     std::memset(buf, 0, sizeof buf);
     std::memcpy(buf[0], x, xBytes);

 }
 
 // Test MIN() and MAX()
 struct ExtremumTestCase {
   std::vector<SubscriptValue> shape; // Empty = scalar, non-empty = array.
   std::vector<const char *> x, y, expect;
 };
 
-// Helper for creating, allocating and filling up a descriptor with data from
-// raw character literals, converted to the CHAR type used by the test.
-template <typename CHAR>
-OwningPtr<Descriptor> CreateDescriptor(const std::vector<SubscriptValue> &shape,
-    const std::vector<const char *> &raw_strings) {
-  std::size_t length{std::strlen(raw_strings[0])};
-
-  OwningPtr<Descriptor> descriptor{Descriptor::Create(sizeof(CHAR), length,
-      nullptr, shape.size(), nullptr, CFI_attribute_allocatable)};
-  if ((shape.empty() ? descriptor->Allocate()
-                     : descriptor->Allocate(
-                           std::vector<SubscriptValue>(shape.size(), 1).data(),
-                           shape.data())) != 0) {
-    return nullptr;
-  }
-
-  std::size_t offset = 0;
-  for (const char *raw : raw_strings) {
-    std::basic_string<CHAR> converted{raw, raw + length};
-    std::copy(converted.begin(), converted.end(),
-        descriptor->OffsetElement<CHAR>(offset * length * sizeof(CHAR)));
-    ++offset;
-  }
-
-  return descriptor;
-}
-
 template <typename CHAR>
 void RunExtremumTests(const char *which,
     std::function<void(Descriptor &, const Descriptor &, const char *, int)>
         function,
     const std::vector<ExtremumTestCase> &testCases) {
   std::stringstream traceMessage;
   traceMessage << which << " for CHARACTER(kind=" << sizeof(CHAR) << ")";
   SCOPED_TRACE(traceMessage.str());