llvm/unittests/ADT/TwineTest.cpp

   1 //===- TwineTest.cpp - Twine unit tests -----------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ADT/Twine.h"
  10 #include "llvm/ADT/SmallString.h"
  11 #include "llvm/Support/FormatAdapters.h"
  12 #include "llvm/Support/FormatVariadic.h"
  13 #include "llvm/Support/raw_ostream.h"
  14 #include "gtest/gtest.h"
  15 using namespace llvm;
  16
  17 namespace {
  18
  19 std::string repr(const Twine &Value) {
  20   std::string res;
  21   llvm::raw_string_ostream OS(res);
  22   Value.printRepr(OS);
  23   return OS.str();
  24 }
  25
  26 TEST(TwineTest, Construction) {
  27   EXPECT_EQ("", Twine().str());
  28   EXPECT_EQ("hi", Twine("hi").str());
  29   EXPECT_EQ("hi", Twine(std::string("hi")).str());
  30   EXPECT_EQ("hi", Twine(StringRef("hi")).str());
  31   EXPECT_EQ("hi", Twine(StringRef(std::string("hi"))).str());
  32   EXPECT_EQ("hi", Twine(StringRef("hithere", 2)).str());
  33   EXPECT_EQ("hi", Twine(StringLiteral("hi")).str());
  34   EXPECT_EQ("hi", Twine(SmallString<4>("hi")).str());
  35   EXPECT_EQ("hi", Twine(formatv("{0}", "hi")).str());
  36   EXPECT_EQ("hi", Twine(std::string_view("hi")).str());
  37 }
  38
  39 TEST(TwineTest, Numbers) {
  40   EXPECT_EQ("123", Twine(123U).str());
  41   EXPECT_EQ("123", Twine(123).str());
  42   EXPECT_EQ("-123", Twine(-123).str());
  43   EXPECT_EQ("123", Twine(123).str());
  44   EXPECT_EQ("-123", Twine(-123).str());
  45
  46   EXPECT_EQ("7b", Twine::utohexstr(123).str());
  47 }
  48
  49 TEST(TwineTest, Characters) {
  50   EXPECT_EQ("x", Twine('x').str());
  51   EXPECT_EQ("x", Twine(static_cast<unsigned char>('x')).str());
  52   EXPECT_EQ("x", Twine(static_cast<signed char>('x')).str());
  53 }
  54
  55 TEST(TwineTest, Concat) {
  56   // Check verse repr, since we care about the actual representation not just
  57   // the result.
  58
  59   // Concat with null.
  60   EXPECT_EQ("(Twine null empty)",
  61             repr(Twine("hi").concat(Twine::createNull())));
  62   EXPECT_EQ("(Twine null empty)",
  63             repr(Twine::createNull().concat(Twine("hi"))));
  64
  65   // Concat with empty.
  66   EXPECT_EQ("(Twine cstring:\"hi\" empty)",
  67             repr(Twine("hi").concat(Twine())));
  68   EXPECT_EQ("(Twine cstring:\"hi\" empty)",
  69             repr(Twine().concat(Twine("hi"))));
  70   EXPECT_EQ("(Twine ptrAndLength:\"hi\" empty)",
  71             repr(Twine().concat(Twine(SmallString<5>("hi")))));
  72   EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
  73             repr(Twine(formatv("howdy")).concat(Twine())));
  74   EXPECT_EQ("(Twine formatv:\"howdy\" empty)",
  75             repr(Twine().concat(Twine(formatv("howdy")))));
  76   EXPECT_EQ("(Twine ptrAndLength:\"hey\" cstring:\"there\")",
  77             repr(Twine(SmallString<7>("hey")).concat(Twine("there"))));
  78   EXPECT_EQ("(Twine ptrAndLength:\"hey\" cstring:\"there\")",
  79             repr(Twine(std::string_view("hey")).concat(Twine("there"))));
  80
  81   // Concatenation of unary ropes.
  82   EXPECT_EQ("(Twine cstring:\"a\" cstring:\"b\")",
  83             repr(Twine("a").concat(Twine("b"))));
  84
  85   // Concatenation of other ropes.
  86   EXPECT_EQ("(Twine rope:(Twine cstring:\"a\" cstring:\"b\") cstring:\"c\")",
  87             repr(Twine("a").concat(Twine("b")).concat(Twine("c"))));
  88   EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine cstring:\"b\" cstring:\"c\"))",
  89             repr(Twine("a").concat(Twine("b").concat(Twine("c")))));
  90   EXPECT_EQ(
  91       "(Twine cstring:\"a\" rope:(Twine ptrAndLength:\"b\" cstring:\"c\"))",
  92       repr(Twine("a").concat(Twine(SmallString<3>("b")).concat(Twine("c")))));
  93 }
  94
  95 TEST(TwineTest, toNullTerminatedStringRef) {
  96   SmallString<8> storage;
  97   EXPECT_EQ(0, *Twine("hello").toNullTerminatedStringRef(storage).end());
  98   EXPECT_EQ(0,
  99            *Twine(StringRef("hello")).toNullTerminatedStringRef(storage).end());
 100   EXPECT_EQ(
 101       0,
 102       *Twine(StringLiteral("hello")).toNullTerminatedStringRef(storage).end());
 103   EXPECT_EQ(0, *Twine(SmallString<11>("hello"))
 104                     .toNullTerminatedStringRef(storage)
 105                     .end());
 106   EXPECT_EQ(0, *Twine(formatv("{0}{1}", "how", "dy"))
 107                     .toNullTerminatedStringRef(storage)
 108                     .end());
 109 }
 110
 111 TEST(TwineTest, isSingleStringLiteral) {
 112   EXPECT_TRUE(Twine(StringLiteral("hi")).isSingleStringLiteral());
 113   EXPECT_FALSE(Twine("hi").isSingleStringLiteral());
 114   EXPECT_FALSE(Twine(StringRef("hi")).isSingleStringLiteral());
 115 }
 116
 117 TEST(TwineTest, LazyEvaluation) {
 118   struct formatter : FormatAdapter<int> {
 119     explicit formatter(int &Count) : FormatAdapter(0), Count(Count) {}
 120     int &Count;
 121
 122     void format(raw_ostream &OS, StringRef Style) override { ++Count; }
 123   };
 124
 125   int Count = 0;
 126   formatter Formatter(Count);
 127   (void)Twine(formatv("{0}", Formatter));
 128   EXPECT_EQ(0, Count);
 129   (void)Twine(formatv("{0}", Formatter)).str();
 130   EXPECT_EQ(1, Count);
 131 }
 132
 133   // I suppose linking in the entire code generator to add a unit test to check
 134   // the code size of the concat operation is overkill... :)
 135
 136 } // end anonymous namespace