sanitizer_common_test.cc revision db9d684d26dc31a7522bb90841d51cbcc84ed23b 
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_libc.h"
16#include "sanitizer_common/sanitizer_platform.h"
17#include "gtest/gtest.h"
18
19namespace __sanitizer {
20
21static bool IsSorted(const uptr *array, uptr n) {
22  for (uptr i = 1; i < n; i++) {
23    if (array[i] < array[i - 1]) return false;
24  }
25  return true;
26}
27
28TEST(SanitizerCommon, SortTest) {
29  uptr array[100];
30  uptr n = 100;
31  // Already sorted.
32  for (uptr i = 0; i < n; i++) {
33    array[i] = i;
34  }
35  SortArray(array, n);
36  EXPECT_TRUE(IsSorted(array, n));
37  // Reverse order.
38  for (uptr i = 0; i < n; i++) {
39    array[i] = n - 1 - i;
40  }
41  SortArray(array, n);
42  EXPECT_TRUE(IsSorted(array, n));
43  // Mixed order.
44  for (uptr i = 0; i < n; i++) {
45    array[i] = (i % 2 == 0) ? i : n - 1 - i;
46  }
47  SortArray(array, n);
48  EXPECT_TRUE(IsSorted(array, n));
49  // All equal.
50  for (uptr i = 0; i < n; i++) {
51    array[i] = 42;
52  }
53  SortArray(array, n);
54  EXPECT_TRUE(IsSorted(array, n));
55  // All but one sorted.
56  for (uptr i = 0; i < n - 1; i++) {
57    array[i] = i;
58  }
59  array[n - 1] = 42;
60  SortArray(array, n);
61  EXPECT_TRUE(IsSorted(array, n));
62  // Minimal case - sort three elements.
63  array[0] = 1;
64  array[1] = 0;
65  SortArray(array, 2);
66  EXPECT_TRUE(IsSorted(array, 2));
67}
68
69TEST(SanitizerCommon, MmapAlignedOrDie) {
70  uptr PageSize = GetPageSizeCached();
71  for (uptr size = 1; size <= 32; size *= 2) {
72    for (uptr alignment = 1; alignment <= 32; alignment *= 2) {
73      for (int iter = 0; iter < 100; iter++) {
74        uptr res = (uptr)MmapAlignedOrDie(
75            size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest");
76        EXPECT_EQ(0U, res % (alignment * PageSize));
77        internal_memset((void*)res, 1, size * PageSize);
78        UnmapOrDie((void*)res, size * PageSize);
79      }
80    }
81  }
82}
83
84#if SANITIZER_LINUX
85TEST(SanitizerCommon, SanitizerSetThreadName) {
86  const char *names[] = {
87    "0123456789012",
88    "01234567890123",
89    "012345678901234",  // Larger names will be truncated on linux.
90  };
91
92  for (size_t i = 0; i < ARRAY_SIZE(names); i++) {
93    EXPECT_TRUE(SanitizerSetThreadName(names[i]));
94    char buff[100];
95    EXPECT_TRUE(SanitizerGetThreadName(buff, sizeof(buff) - 1));
96    EXPECT_EQ(0, internal_strcmp(buff, names[i]));
97  }
98}
99#endif
100
101TEST(SanitizerCommon, InternalMmapVector) {
102  InternalMmapVector<uptr> vector(1);
103  for (uptr i = 0; i < 100; i++) {
104    EXPECT_EQ(i, vector.size());
105    vector.push_back(i);
106  }
107  for (uptr i = 0; i < 100; i++) {
108    EXPECT_EQ(i, vector[i]);
109  }
110  for (int i = 99; i >= 0; i--) {
111    EXPECT_EQ((uptr)i, vector.back());
112    vector.pop_back();
113    EXPECT_EQ((uptr)i, vector.size());
114  }
115}
116
117void TestThreadInfo(bool main) {
118  uptr stk_addr = 0;
119  uptr stk_size = 0;
120  uptr tls_addr = 0;
121  uptr tls_size = 0;
122  GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size);
123
124  int stack_var;
125  EXPECT_NE(stk_addr, (uptr)0);
126  EXPECT_NE(stk_size, (uptr)0);
127  EXPECT_GT((uptr)&stack_var, stk_addr);
128  EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
129
130#if SANITIZER_LINUX && defined(__x86_64__)
131  static __thread int thread_var;
132  EXPECT_NE(tls_addr, (uptr)0);
133  EXPECT_NE(tls_size, (uptr)0);
134  EXPECT_GT((uptr)&thread_var, tls_addr);
135  EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
136
137  // Ensure that tls and stack do not intersect.
138  uptr tls_end = tls_addr + tls_size;
139  EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
140  EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
141  EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
142#endif
143}
144
145static void *WorkerThread(void *arg) {
146  TestThreadInfo(false);
147  return 0;
148}
149
150TEST(SanitizerCommon, ThreadStackTlsMain) {
151  InitTlsSize();
152  TestThreadInfo(true);
153}
154
155TEST(SanitizerCommon, ThreadStackTlsWorker) {
156  InitTlsSize();
157  pthread_t t;
158  pthread_create(&t, 0, WorkerThread, 0);
159  pthread_join(t, 0);
160}
161
162bool UptrLess(uptr a, uptr b) {
163  return a < b;
164}
165
166TEST(SanitizerCommon, InternalBinarySearch) {
167  static const uptr kSize = 5;
168  uptr arr[kSize];
169  for (uptr i = 0; i < kSize; i++) arr[i] = i * i;
170
171  for (uptr i = 0; i < kSize; i++)
172    ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, i * i, UptrLess), i);
173
174  ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, 7, UptrLess), kSize + 1);
175}
176
177#if SANITIZER_LINUX && !SANITIZER_ANDROID
178TEST(SanitizerCommon, FindPathToBinary) {
179  char *true_path = FindPathToBinary("true");
180  EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
181  InternalFree(true_path);
182  EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
183}
184#endif
185
186}  // namespace __sanitizer
187