compiler-rt/lib/sanitizer_common/tests/sanitizer_flags_test.cpp

   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