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
TEST(ConstStringTest,format_provider)16 TEST(ConstStringTest, format_provider) {
17 EXPECT_EQ("foo", llvm::formatv("{0}", ConstString("foo")).str());
18 }
19
TEST(ConstStringTest,MangledCounterpart)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
TEST(ConstStringTest,UpdateMangledCounterpart)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
TEST(ConstStringTest,FromMidOfBufferStringRef)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
TEST(ConstStringTest,NullAndEmptyStates)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
TEST(ConstStringTest,CompareConstString)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
TEST(ConstStringTest,CompareStringRef)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
TEST(ConstStringTest,YAML)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 }
160