1 //===-- sanitizer_common_test.cc ------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "sanitizer_common/sanitizer_allocator_internal.h"
14 #include "sanitizer_common/sanitizer_common.h"
15 #include "sanitizer_common/sanitizer_flags.h"
16 #include "sanitizer_common/sanitizer_libc.h"
17 #include "sanitizer_common/sanitizer_platform.h"
18
19 #include "sanitizer_pthread_wrappers.h"
20
21 #include "gtest/gtest.h"
22
23 namespace __sanitizer {
24
IsSorted(const uptr * array,uptr n)25 static bool IsSorted(const uptr *array, uptr n) {
26 for (uptr i = 1; i < n; i++) {
27 if (array[i] < array[i - 1]) return false;
28 }
29 return true;
30 }
31
TEST(SanitizerCommon,SortTest)32 TEST(SanitizerCommon, SortTest) {
33 uptr array[100];
34 uptr n = 100;
35 // Already sorted.
36 for (uptr i = 0; i < n; i++) {
37 array[i] = i;
38 }
39 SortArray(array, n);
40 EXPECT_TRUE(IsSorted(array, n));
41 // Reverse order.
42 for (uptr i = 0; i < n; i++) {
43 array[i] = n - 1 - i;
44 }
45 SortArray(array, n);
46 EXPECT_TRUE(IsSorted(array, n));
47 // Mixed order.
48 for (uptr i = 0; i < n; i++) {
49 array[i] = (i % 2 == 0) ? i : n - 1 - i;
50 }
51 SortArray(array, n);
52 EXPECT_TRUE(IsSorted(array, n));
53 // All equal.
54 for (uptr i = 0; i < n; i++) {
55 array[i] = 42;
56 }
57 SortArray(array, n);
58 EXPECT_TRUE(IsSorted(array, n));
59 // All but one sorted.
60 for (uptr i = 0; i < n - 1; i++) {
61 array[i] = i;
62 }
63 array[n - 1] = 42;
64 SortArray(array, n);
65 EXPECT_TRUE(IsSorted(array, n));
66 // Minimal case - sort three elements.
67 array[0] = 1;
68 array[1] = 0;
69 SortArray(array, 2);
70 EXPECT_TRUE(IsSorted(array, 2));
71 }
72
TEST(SanitizerCommon,MmapAlignedOrDie)73 TEST(SanitizerCommon, MmapAlignedOrDie) {
74 uptr PageSize = GetPageSizeCached();
75 for (uptr size = 1; size <= 32; size *= 2) {
76 for (uptr alignment = 1; alignment <= 32; alignment *= 2) {
77 for (int iter = 0; iter < 100; iter++) {
78 uptr res = (uptr)MmapAlignedOrDie(
79 size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest");
80 EXPECT_EQ(0U, res % (alignment * PageSize));
81 internal_memset((void*)res, 1, size * PageSize);
82 UnmapOrDie((void*)res, size * PageSize);
83 }
84 }
85 }
86 }
87
88 #if SANITIZER_LINUX
TEST(SanitizerCommon,SanitizerSetThreadName)89 TEST(SanitizerCommon, SanitizerSetThreadName) {
90 const char *names[] = {
91 "0123456789012",
92 "01234567890123",
93 "012345678901234", // Larger names will be truncated on linux.
94 };
95
96 for (size_t i = 0; i < ARRAY_SIZE(names); i++) {
97 EXPECT_TRUE(SanitizerSetThreadName(names[i]));
98 char buff[100];
99 EXPECT_TRUE(SanitizerGetThreadName(buff, sizeof(buff) - 1));
100 EXPECT_EQ(0, internal_strcmp(buff, names[i]));
101 }
102 }
103 #endif
104
TEST(SanitizerCommon,InternalMmapVector)105 TEST(SanitizerCommon, InternalMmapVector) {
106 InternalMmapVector<uptr> vector(1);
107 for (uptr i = 0; i < 100; i++) {
108 EXPECT_EQ(i, vector.size());
109 vector.push_back(i);
110 }
111 for (uptr i = 0; i < 100; i++) {
112 EXPECT_EQ(i, vector[i]);
113 }
114 for (int i = 99; i >= 0; i--) {
115 EXPECT_EQ((uptr)i, vector.back());
116 vector.pop_back();
117 EXPECT_EQ((uptr)i, vector.size());
118 }
119 InternalMmapVector<uptr> empty_vector(0);
120 CHECK_GT(empty_vector.capacity(), 0U);
121 CHECK_EQ(0U, empty_vector.size());
122 }
123
TestThreadInfo(bool main)124 void TestThreadInfo(bool main) {
125 uptr stk_addr = 0;
126 uptr stk_size = 0;
127 uptr tls_addr = 0;
128 uptr tls_size = 0;
129 GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size);
130
131 int stack_var;
132 EXPECT_NE(stk_addr, (uptr)0);
133 EXPECT_NE(stk_size, (uptr)0);
134 EXPECT_GT((uptr)&stack_var, stk_addr);
135 EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
136
137 #if SANITIZER_LINUX && defined(__x86_64__)
138 static __thread int thread_var;
139 EXPECT_NE(tls_addr, (uptr)0);
140 EXPECT_NE(tls_size, (uptr)0);
141 EXPECT_GT((uptr)&thread_var, tls_addr);
142 EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
143
144 // Ensure that tls and stack do not intersect.
145 uptr tls_end = tls_addr + tls_size;
146 EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
147 EXPECT_TRUE(tls_end < stk_addr || tls_end >= stk_addr + stk_size);
148 EXPECT_TRUE((tls_addr < stk_addr) == (tls_end < stk_addr));
149 #endif
150 }
151
WorkerThread(void * arg)152 static void *WorkerThread(void *arg) {
153 TestThreadInfo(false);
154 return 0;
155 }
156
TEST(SanitizerCommon,ThreadStackTlsMain)157 TEST(SanitizerCommon, ThreadStackTlsMain) {
158 InitTlsSize();
159 TestThreadInfo(true);
160 }
161
TEST(SanitizerCommon,ThreadStackTlsWorker)162 TEST(SanitizerCommon, ThreadStackTlsWorker) {
163 InitTlsSize();
164 pthread_t t;
165 PTHREAD_CREATE(&t, 0, WorkerThread, 0);
166 PTHREAD_JOIN(t, 0);
167 }
168
UptrLess(uptr a,uptr b)169 bool UptrLess(uptr a, uptr b) {
170 return a < b;
171 }
172
TEST(SanitizerCommon,InternalBinarySearch)173 TEST(SanitizerCommon, InternalBinarySearch) {
174 static const uptr kSize = 5;
175 uptr arr[kSize];
176 for (uptr i = 0; i < kSize; i++) arr[i] = i * i;
177
178 for (uptr i = 0; i < kSize; i++)
179 ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, i * i, UptrLess), i);
180
181 ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, 7, UptrLess), kSize + 1);
182 }
183
184 #if SANITIZER_LINUX && !SANITIZER_ANDROID
TEST(SanitizerCommon,FindPathToBinary)185 TEST(SanitizerCommon, FindPathToBinary) {
186 char *true_path = FindPathToBinary("true");
187 EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
188 InternalFree(true_path);
189 EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
190 }
191 #elif SANITIZER_WINDOWS
TEST(SanitizerCommon,FindPathToBinary)192 TEST(SanitizerCommon, FindPathToBinary) {
193 // ntdll.dll should be on PATH in all supported test environments on all
194 // supported Windows versions.
195 char *ntdll_path = FindPathToBinary("ntdll.dll");
196 EXPECT_NE((char*)0, internal_strstr(ntdll_path, "ntdll.dll"));
197 InternalFree(ntdll_path);
198 EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
199 }
200 #endif
201
TEST(SanitizerCommon,StripPathPrefix)202 TEST(SanitizerCommon, StripPathPrefix) {
203 EXPECT_EQ(0, StripPathPrefix(0, "prefix"));
204 EXPECT_STREQ("foo", StripPathPrefix("foo", 0));
205 EXPECT_STREQ("dir/file.cc",
206 StripPathPrefix("/usr/lib/dir/file.cc", "/usr/lib/"));
207 EXPECT_STREQ("/file.cc", StripPathPrefix("/usr/myroot/file.cc", "/myroot"));
208 EXPECT_STREQ("file.h", StripPathPrefix("/usr/lib/./file.h", "/usr/lib/"));
209 }
210
TEST(SanitizerCommon,RemoveANSIEscapeSequencesFromString)211 TEST(SanitizerCommon, RemoveANSIEscapeSequencesFromString) {
212 RemoveANSIEscapeSequencesFromString(nullptr);
213 const char *buffs[22] = {
214 "Default", "Default",
215 "\033[95mLight magenta", "Light magenta",
216 "\033[30mBlack\033[32mGreen\033[90mGray", "BlackGreenGray",
217 "\033[106mLight cyan \033[107mWhite ", "Light cyan White ",
218 "\033[31mHello\033[0m World", "Hello World",
219 "\033[38;5;82mHello \033[38;5;198mWorld", "Hello World",
220 "123[653456789012", "123[653456789012",
221 "Normal \033[5mBlink \033[25mNormal", "Normal Blink Normal",
222 "\033[106m\033[107m", "",
223 "", "",
224 " ", " ",
225 };
226
227 for (size_t i = 0; i < ARRAY_SIZE(buffs); i+=2) {
228 char *buffer_copy = internal_strdup(buffs[i]);
229 RemoveANSIEscapeSequencesFromString(buffer_copy);
230 EXPECT_STREQ(buffer_copy, buffs[i+1]);
231 InternalFree(buffer_copy);
232 }
233 }
234
TEST(SanitizerCommon,InternalScopedString)235 TEST(SanitizerCommon, InternalScopedString) {
236 InternalScopedString str(10);
237 EXPECT_EQ(0U, str.length());
238 EXPECT_STREQ("", str.data());
239
240 str.append("foo");
241 EXPECT_EQ(3U, str.length());
242 EXPECT_STREQ("foo", str.data());
243
244 int x = 1234;
245 str.append("%d", x);
246 EXPECT_EQ(7U, str.length());
247 EXPECT_STREQ("foo1234", str.data());
248
249 str.append("%d", x);
250 EXPECT_EQ(9U, str.length());
251 EXPECT_STREQ("foo123412", str.data());
252
253 str.clear();
254 EXPECT_EQ(0U, str.length());
255 EXPECT_STREQ("", str.data());
256
257 str.append("0123456789");
258 EXPECT_EQ(9U, str.length());
259 EXPECT_STREQ("012345678", str.data());
260 }
261
262 } // namespace __sanitizer
263