| 1 |
//===-- sanitizer_flags_test.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 |
// This file is a part of ThreadSanitizer/AddressSanitizer runtime. |
| 10 |
// |
| 11 |
//===----------------------------------------------------------------------===// |
| 12 |
#include "sanitizer_common/sanitizer_common.h" |
| 13 |
#include "sanitizer_common/sanitizer_flags.h" |
| 14 |
#include "sanitizer_common/sanitizer_flag_parser.h" |
| 15 |
#include "sanitizer_common/sanitizer_libc.h" |
| 16 |
#include "sanitizer_common/sanitizer_allocator_internal.h" |
| 17 |
#include "gtest/gtest.h" |
| 18 |
|
| 19 |
#include <stdint.h> |
| 20 |
#include <string.h> |
| 21 |
|
| 22 |
namespace __sanitizer { |
| 23 |
|
| 24 |
static const char kFlagName[] = "flag_name"; |
| 25 |
static const char kFlagDesc[] = "flag description"; |
| 26 |
|
| 27 |
template <typename T> |
| 28 |
static void TestFlag(T start_value, const char *env, T final_value) { |
| 29 |
T flag = start_value; |
| 30 |
|
| 31 |
FlagParser parser; |
| 32 |
RegisterFlag(&parser, kFlagName, kFlagDesc, &flag); |
| 33 |
|
| 34 |
parser.ParseString(env); |
| 35 |
|
| 36 |
EXPECT_EQ(final_value, flag); |
| 37 |
|
| 38 |
// Reporting unrecognized flags is needed to reset them. |
| 39 |
ReportUnrecognizedFlags(); |
| 40 |
} |
| 41 |
|
| 42 |
template <> |
| 43 |
void TestFlag(const char *start_value, const char *env, |
| 44 |
const char *final_value) { |
| 45 |
const char *flag = start_value; |
| 46 |
|
| 47 |
FlagParser parser; |
| 48 |
RegisterFlag(&parser, kFlagName, kFlagDesc, &flag); |
| 49 |
|
| 50 |
parser.ParseString(env); |
| 51 |
|
| 52 |
EXPECT_EQ(0, internal_strcmp(final_value, flag)); |
| 53 |
|
| 54 |
// Reporting unrecognized flags is needed to reset them. |
| 55 |
ReportUnrecognizedFlags(); |
| 56 |
} |
| 57 |
|
| 58 |
TEST(SanitizerCommon, BooleanFlags) { |
| 59 |
TestFlag(false, "flag_name=1", true); |
| 60 |
TestFlag(false, "flag_name=yes", true); |
| 61 |
TestFlag(false, "flag_name=true", true); |
| 62 |
TestFlag(true, "flag_name=0", false); |
| 63 |
TestFlag(true, "flag_name=no", false); |
| 64 |
TestFlag(true, "flag_name=false", false); |
| 65 |
|
| 66 |
EXPECT_DEATH(TestFlag(false, "flag_name", true), "expected '='"); |
| 67 |
EXPECT_DEATH(TestFlag(false, "flag_name=", true), |
| 68 |
"Invalid value for bool option: ''"); |
| 69 |
EXPECT_DEATH(TestFlag(false, "flag_name=2", true), |
| 70 |
"Invalid value for bool option: '2'"); |
| 71 |
EXPECT_DEATH(TestFlag(false, "flag_name=-1", true), |
| 72 |
"Invalid value for bool option: '-1'"); |
| 73 |
EXPECT_DEATH(TestFlag(false, "flag_name=on", true), |
| 74 |
"Invalid value for bool option: 'on'"); |
| 75 |
} |
| 76 |
|
| 77 |
TEST(SanitizerCommon, HandleSignalMode) { |
| 78 |
TestFlag(kHandleSignalNo, "flag_name=1", kHandleSignalYes); |
| 79 |
TestFlag(kHandleSignalNo, "flag_name=yes", kHandleSignalYes); |
| 80 |
TestFlag(kHandleSignalNo, "flag_name=true", kHandleSignalYes); |
| 81 |
TestFlag(kHandleSignalYes, "flag_name=0", kHandleSignalNo); |
| 82 |
TestFlag(kHandleSignalYes, "flag_name=no", kHandleSignalNo); |
| 83 |
TestFlag(kHandleSignalYes, "flag_name=false", kHandleSignalNo); |
| 84 |
TestFlag(kHandleSignalNo, "flag_name=2", kHandleSignalExclusive); |
| 85 |
TestFlag(kHandleSignalYes, "flag_name=exclusive", kHandleSignalExclusive); |
| 86 |
|
| 87 |
EXPECT_DEATH(TestFlag(kHandleSignalNo, "flag_name", kHandleSignalNo), |
| 88 |
"expected '='"); |
| 89 |
EXPECT_DEATH(TestFlag(kHandleSignalNo, "flag_name=", kHandleSignalNo), |
| 90 |
"Invalid value for signal handler option: ''"); |
| 91 |
EXPECT_DEATH(TestFlag(kHandleSignalNo, "flag_name=3", kHandleSignalNo), |
| 92 |
"Invalid value for signal handler option: '3'"); |
| 93 |
EXPECT_DEATH(TestFlag(kHandleSignalNo, "flag_name=-1", kHandleSignalNo), |
| 94 |
"Invalid value for signal handler option: '-1'"); |
| 95 |
EXPECT_DEATH(TestFlag(kHandleSignalNo, "flag_name=on", kHandleSignalNo), |
| 96 |
"Invalid value for signal handler option: 'on'"); |
| 97 |
} |
| 98 |
|
| 99 |
TEST(SanitizerCommon, IntFlags) { |
| 100 |
TestFlag(-11, 0, -11); |
| 101 |
TestFlag(-11, "flag_name=0", 0); |
| 102 |
TestFlag(-11, "flag_name=42", 42); |
| 103 |
TestFlag(-11, "flag_name=-42", -42); |
| 104 |
|
| 105 |
// Unrecognized flags are ignored. |
| 106 |
TestFlag(-11, "--flag_name=42", -11); |
| 107 |
TestFlag(-11, "zzzzzzz=42", -11); |
| 108 |
|
| 109 |
EXPECT_DEATH(TestFlag(-11, "flag_name", 0), "expected '='"); |
| 110 |
EXPECT_DEATH(TestFlag(-11, "flag_name=42U", 0), |
| 111 |
"Invalid value for int option"); |
| 112 |
} |
| 113 |
|
| 114 |
TEST(SanitizerCommon, LongLongIntFlags) { |
| 115 |
s64 InitValue = -5; |
| 116 |
s64 IntMin = INT64_MIN; |
| 117 |
s64 IntMax = INT64_MAX; |
| 118 |
TestFlag(InitValue, "flag_name=0", 0ll); |
| 119 |
TestFlag(InitValue, "flag_name=42", 42ll); |
| 120 |
TestFlag(InitValue, "flag_name=-42", -42ll); |
| 121 |
|
| 122 |
TestFlag(InitValue, "flag_name=-9223372036854775808", IntMin); |
| 123 |
TestFlag(InitValue, "flag_name=9223372036854775807", IntMax); |
| 124 |
|
| 125 |
TestFlag(InitValue, "flag_name=-92233720368547758080000", IntMin); |
| 126 |
TestFlag(InitValue, "flag_name=92233720368547758070000", IntMax); |
| 127 |
} |
| 128 |
|
| 129 |
TEST(SanitizerCommon, StrFlags) { |
| 130 |
TestFlag("zzz", 0, "zzz"); |
| 131 |
TestFlag("zzz", "flag_name=", ""); |
| 132 |
TestFlag("zzz", "flag_name=abc", "abc"); |
| 133 |
TestFlag("", "flag_name=abc", "abc"); |
| 134 |
TestFlag("", "flag_name='abc zxc'", "abc zxc"); |
| 135 |
// TestStrFlag("", "flag_name=\"abc qwe\" asd", "abc qwe"); |
| 136 |
} |
| 137 |
|
| 138 |
static void TestTwoFlags(const char *env, bool expected_flag1, |
| 139 |
const char *expected_flag2, |
| 140 |
const char *name1 = "flag1", |
| 141 |
const char *name2 = "flag2") { |
| 142 |
bool flag1 = !expected_flag1; |
| 143 |
const char *flag2 = ""; |
| 144 |
|
| 145 |
FlagParser parser; |
| 146 |
RegisterFlag(&parser, name1, kFlagDesc, &flag1); |
| 147 |
RegisterFlag(&parser, name2, kFlagDesc, &flag2); |
| 148 |
|
| 149 |
parser.ParseString(env); |
| 150 |
|
| 151 |
EXPECT_EQ(expected_flag1, flag1); |
| 152 |
EXPECT_EQ(0, internal_strcmp(flag2, expected_flag2)); |
| 153 |
|
| 154 |
// Reporting unrecognized flags is needed to reset them. |
| 155 |
ReportUnrecognizedFlags(); |
| 156 |
} |
| 157 |
|
| 158 |
TEST(SanitizerCommon, MultipleFlags) { |
| 159 |
TestTwoFlags("flag1=1 flag2='zzz'", true, "zzz"); |
| 160 |
TestTwoFlags("flag2='qxx' flag1=0", false, "qxx"); |
| 161 |
TestTwoFlags("flag1=false:flag2='zzz'", false, "zzz"); |
| 162 |
TestTwoFlags("flag2=qxx:flag1=yes", true, "qxx"); |
| 163 |
TestTwoFlags("flag2=qxx\nflag1=yes", true, "qxx"); |
| 164 |
TestTwoFlags("flag2=qxx\r\nflag1=yes", true, "qxx"); |
| 165 |
TestTwoFlags("flag2=qxx\tflag1=yes", true, "qxx"); |
| 166 |
} |
| 167 |
|
| 168 |
TEST(SanitizerCommon, CommonSuffixFlags) { |
| 169 |
TestTwoFlags("flag=1 other_flag='zzz'", true, "zzz", "flag", "other_flag"); |
| 170 |
TestTwoFlags("other_flag='zzz' flag=1", true, "zzz", "flag", "other_flag"); |
| 171 |
TestTwoFlags("other_flag=' flag=0 ' flag=1", true, " flag=0 ", "flag", |
| 172 |
"other_flag"); |
| 173 |
TestTwoFlags("flag=1 other_flag=' flag=0 '", true, " flag=0 ", "flag", |
| 174 |
"other_flag"); |
| 175 |
} |
| 176 |
|
| 177 |
TEST(SanitizerCommon, CommonFlags) { |
| 178 |
CommonFlags cf; |
| 179 |
FlagParser parser; |
| 180 |
RegisterCommonFlags(&parser, &cf); |
| 181 |
|
| 182 |
cf.SetDefaults(); |
| 183 |
EXPECT_TRUE(cf.symbolize); |
| 184 |
EXPECT_STREQ(".", cf.coverage_dir); |
| 185 |
|
| 186 |
cf.symbolize = false; |
| 187 |
cf.coverage = true; |
| 188 |
cf.heap_profile = true; |
| 189 |
cf.log_path = "path/one"; |
| 190 |
|
| 191 |
parser.ParseString("symbolize=1:heap_profile=false log_path='path/two'"); |
| 192 |
EXPECT_TRUE(cf.symbolize); |
| 193 |
EXPECT_TRUE(cf.coverage); |
| 194 |
EXPECT_FALSE(cf.heap_profile); |
| 195 |
EXPECT_STREQ("path/two", cf.log_path); |
| 196 |
} |
| 197 |
|
| 198 |
} // namespace __sanitizer |