lldb/unittests/Utility/ConstStringTest.cpp

   1 //===-- ConstStringTest.cpp -----------------------------------------------===//
   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 "lldb/Utility/ConstString.h"
  10 #include "llvm/Support/FormatVariadic.h"
  11 #include "llvm/Support/YAMLParser.h"
  12 #include "gtest/gtest.h"
  13
  14 using namespace lldb_private;
  15
  16 TEST(ConstStringTest, format_provider) {
  17   EXPECT_EQ("foo", llvm::formatv("{0}", ConstString("foo")).str());
  18 }
  19
  20 TEST(ConstStringTest, MangledCounterpart) {
  21   ConstString uvw("uvw");
  22   ConstString counterpart;
  23   EXPECT_FALSE(uvw.GetMangledCounterpart(counterpart));
  24   EXPECT_EQ("", counterpart.GetStringRef());
  25
  26   ConstString xyz;
  27   xyz.SetStringWithMangledCounterpart("xyz", uvw);
  28   EXPECT_EQ("xyz", xyz.GetStringRef());
  29
  30   EXPECT_TRUE(xyz.GetMangledCounterpart(counterpart));
  31   EXPECT_EQ("uvw", counterpart.GetStringRef());
  32
  33   EXPECT_TRUE(uvw.GetMangledCounterpart(counterpart));
  34   EXPECT_EQ("xyz", counterpart.GetStringRef());
  35 }
  36
  37 TEST(ConstStringTest, UpdateMangledCounterpart) {
  38   { // Add counterpart
  39     ConstString some1;
  40     some1.SetStringWithMangledCounterpart("some", ConstString(""));
  41   }
  42   { // Overwrite empty string
  43     ConstString some2;
  44     some2.SetStringWithMangledCounterpart("some", ConstString("one"));
  45   }
  46   { // Overwrite with identical value
  47     ConstString some2;
  48     some2.SetStringWithMangledCounterpart("some", ConstString("one"));
  49   }
  50   { // Check counterpart is set
  51     ConstString counterpart;
  52     EXPECT_TRUE(ConstString("some").GetMangledCounterpart(counterpart));
  53     EXPECT_EQ("one", counterpart.GetStringRef());
  54   }
  55 }
  56
  57 TEST(ConstStringTest, FromMidOfBufferStringRef) {
  58   // StringRef's into bigger buffer: no null termination
  59   const char *buffer = "abcdefghi";
  60   llvm::StringRef foo_ref(buffer, 3);
  61   llvm::StringRef bar_ref(buffer + 3, 3);
  62
  63   ConstString foo(foo_ref);
  64
  65   ConstString bar;
  66   bar.SetStringWithMangledCounterpart(bar_ref, foo);
  67   EXPECT_EQ("def", bar.GetStringRef());
  68
  69   ConstString counterpart;
  70   EXPECT_TRUE(bar.GetMangledCounterpart(counterpart));
  71   EXPECT_EQ("abc", counterpart.GetStringRef());
  72
  73   EXPECT_TRUE(foo.GetMangledCounterpart(counterpart));
  74   EXPECT_EQ("def", counterpart.GetStringRef());
  75 }
  76
  77 TEST(ConstStringTest, NullAndEmptyStates) {
  78   ConstString foo("foo");
  79   EXPECT_FALSE(!foo);
  80   EXPECT_FALSE(foo.IsEmpty());
  81   EXPECT_FALSE(foo.IsNull());
  82
  83   ConstString empty("");
  84   EXPECT_TRUE(!empty);
  85   EXPECT_TRUE(empty.IsEmpty());
  86   EXPECT_FALSE(empty.IsNull());
  87
  88   ConstString null;
  89   EXPECT_TRUE(!null);
  90   EXPECT_TRUE(null.IsEmpty());
  91   EXPECT_TRUE(null.IsNull());
  92 }
  93
  94 TEST(ConstStringTest, CompareConstString) {
  95   ConstString foo("foo");
  96   ConstString foo2("foo");
  97   ConstString bar("bar");
  98
  99   EXPECT_TRUE(foo == foo2);
 100   EXPECT_TRUE(foo2 == foo);
 101   EXPECT_TRUE(foo == ConstString("foo"));
 102
 103   EXPECT_FALSE(foo == bar);
 104   EXPECT_FALSE(foo2 == bar);
 105   EXPECT_FALSE(foo == ConstString("bar"));
 106   EXPECT_FALSE(foo == ConstString("different"));
 107   EXPECT_FALSE(foo == ConstString(""));
 108   EXPECT_FALSE(foo == ConstString());
 109
 110   ConstString empty("");
 111   EXPECT_FALSE(empty == ConstString("bar"));
 112   EXPECT_FALSE(empty == ConstString());
 113   EXPECT_TRUE(empty == ConstString(""));
 114
 115   ConstString null;
 116   EXPECT_FALSE(null == ConstString("bar"));
 117   EXPECT_TRUE(null == ConstString());
 118   EXPECT_FALSE(null == ConstString(""));
 119 }
 120
 121 TEST(ConstStringTest, CompareStringRef) {
 122   ConstString foo("foo");
 123
 124   EXPECT_TRUE(foo == "foo");
 125   EXPECT_TRUE(foo != "");
 126   EXPECT_FALSE(foo == static_cast<const char *>(nullptr));
 127   EXPECT_TRUE(foo != "bar");
 128
 129   ConstString empty("");
 130   EXPECT_FALSE(empty == "foo");
 131   EXPECT_FALSE(empty != "");
 132   EXPECT_FALSE(empty == static_cast<const char *>(nullptr));
 133   EXPECT_TRUE(empty != "bar");
 134
 135   ConstString null;
 136   EXPECT_FALSE(null == "foo");
 137   EXPECT_TRUE(null != "");
 138   EXPECT_TRUE(null == static_cast<const char *>(nullptr));
 139   EXPECT_TRUE(null != "bar");
 140 }
 141
 142 TEST(ConstStringTest, YAML) {
 143   std::string buffer;
 144   llvm::raw_string_ostream os(buffer);
 145
 146   // Serialize.
 147   std::vector<ConstString> strings = {ConstString("foo"), ConstString("bar"),
 148                                       ConstString("")};
 149   llvm::yaml::Output yout(os);
 150   yout << strings;
 151   os.flush();
 152
 153   // Deserialize.
 154   std::vector<ConstString> deserialized;
 155   llvm::yaml::Input yin(buffer);
 156   yin >> deserialized;
 157
 158   EXPECT_EQ(strings, deserialized);
 159 }