// Copyright 2014 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "util/mach/symbolic_constants_mach.h"

#include <mach/mach.h>
#include <string.h>
#include <sys/types.h>

#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "util/mach/mach_extensions.h"
#include "util/misc/implicit_cast.h"

#define NUL_TEST_DATA(string) { string, arraysize(string) - 1 }

namespace crashpad {
namespace test {
namespace {

// Options to use for normal tests, those that don’t require kAllowOr.
const StringToSymbolicConstantOptions kNormalOptions[] = {
    0,
    kAllowFullName,
    kAllowShortName,
    kAllowFullName | kAllowShortName,
    kAllowNumber,
    kAllowFullName | kAllowNumber,
    kAllowShortName | kAllowNumber,
    kAllowFullName | kAllowShortName | kAllowNumber,
};

// If |expect| is nullptr, the conversion is expected to fail. If |expect| is
// empty, the conversion is expected to succeed, but the precise returned string
// value is unknown. Otherwise, the conversion is expected to succeed, and
// |expect| contains the precise expected string value to be returned. If
// |expect| contains the substring "0x1", the conversion is expected only to
// succeed when kUnknownIsNumeric is set.
//
// Only set kUseFullName or kUseShortName when calling this. Other options are
// exercised directly by this function.
template <typename Traits>
void TestSomethingToStringOnce(typename Traits::ValueType value,
                               const char* expect,
                               SymbolicConstantToStringOptions options) {
  std::string actual =
      Traits::SomethingToString(value, options | kUnknownIsEmpty | kUseOr);
  std::string actual_numeric =
      Traits::SomethingToString(value, options | kUnknownIsNumeric | kUseOr);
  if (expect) {
    if (expect[0] == '\0') {
      EXPECT_FALSE(actual.empty()) << Traits::kValueName << " " << value;
    } else if (strstr(expect, "0x1")) {
      EXPECT_TRUE(actual.empty()) << Traits::kValueName << " " << value
                                  << ", actual " << actual;
      actual.assign(expect);
    } else {
      EXPECT_EQ(expect, actual) << Traits::kValueName << " " << value;
    }
    EXPECT_EQ(actual, actual_numeric) << Traits::kValueName << " " << value;
  } else {
    EXPECT_TRUE(actual.empty()) << Traits::kValueName << " " << value
                                << ", actual " << actual;
    EXPECT_FALSE(actual_numeric.empty()) << Traits::kValueName << " " << value
                                         << ", actual_numeric "
                                         << actual_numeric;
  }
}

template <typename Traits>
void TestSomethingToString(typename Traits::ValueType value,
                           const char* expect_full,
                           const char* expect_short) {
  {
    SCOPED_TRACE("full_name");
    TestSomethingToStringOnce<Traits>(value, expect_full, kUseFullName);
  }

  {
    SCOPED_TRACE("short_name");
    TestSomethingToStringOnce<Traits>(value, expect_short, kUseShortName);
  }
}

template <typename Traits>
void TestStringToSomething(const base::StringPiece& string,
                           StringToSymbolicConstantOptions options,
                           bool expect_result,
                           typename Traits::ValueType expect_value) {
  typename Traits::ValueType actual_value;
  bool actual_result =
      Traits::StringToSomething(string, options, &actual_value);
  if (expect_result) {
    EXPECT_TRUE(actual_result) << "string " << string << ", options " << options
                               << ", " << Traits::kValueName << " "
                               << expect_value;
    if (actual_result) {
      EXPECT_EQ(expect_value, actual_value) << "string " << string
                                            << ", options " << options;
    }
  } else {
    EXPECT_FALSE(actual_result) << "string " << string << ", options "
                                << options << ", " << Traits::kValueName << " "
                                << actual_value;
  }
}

const struct {
  exception_type_t exception;
  const char* full_name;
  const char* short_name;
} kExceptionTestData[] = {
    {EXC_BAD_ACCESS, "EXC_BAD_ACCESS", "BAD_ACCESS"},
    {EXC_BAD_INSTRUCTION, "EXC_BAD_INSTRUCTION", "BAD_INSTRUCTION"},
    {EXC_ARITHMETIC, "EXC_ARITHMETIC", "ARITHMETIC"},
    {EXC_EMULATION, "EXC_EMULATION", "EMULATION"},
    {EXC_SOFTWARE, "EXC_SOFTWARE", "SOFTWARE"},
    {EXC_MACH_SYSCALL, "EXC_MACH_SYSCALL", "MACH_SYSCALL"},
    {EXC_RPC_ALERT, "EXC_RPC_ALERT", "RPC_ALERT"},
    {EXC_CRASH, "EXC_CRASH", "CRASH"},
    {EXC_RESOURCE, "EXC_RESOURCE", "RESOURCE"},
    {EXC_GUARD, "EXC_GUARD", "GUARD"},
};

struct ConvertExceptionTraits {
  using ValueType = exception_type_t;
  static std::string SomethingToString(
      ValueType value,
      SymbolicConstantToStringOptions options) {
    return ExceptionToString(value, options);
  }
  static bool StringToSomething(const base::StringPiece& string,
                                StringToSymbolicConstantOptions options,
                                ValueType* value) {
    return StringToException(string, options, value);
  }
  static const char kValueName[];
};
const char ConvertExceptionTraits::kValueName[] = "exception";

void TestExceptionToString(exception_type_t value,
                           const char* expect_full,
                           const char* expect_short) {
  return TestSomethingToString<ConvertExceptionTraits>(
      value, expect_full, expect_short);
}

TEST(SymbolicConstantsMach, ExceptionToString) {
  for (size_t index = 0; index < arraysize(kExceptionTestData); ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestExceptionToString(kExceptionTestData[index].exception,
                          kExceptionTestData[index].full_name,
                          kExceptionTestData[index].short_name);
  }

  for (exception_type_t exception = 0;
       exception < EXC_TYPES_COUNT + 8;
       ++exception) {
    SCOPED_TRACE(base::StringPrintf("exception %d", exception));
    if (exception > 0 && exception < EXC_TYPES_COUNT) {
      TestExceptionToString(exception, "", "");
    } else {
      TestExceptionToString(exception, nullptr, nullptr);
    }
  }
}

void TestStringToException(const base::StringPiece& string,
                           StringToSymbolicConstantOptions options,
                           bool expect_result,
                           exception_type_t expect_value) {
  return TestStringToSomething<ConvertExceptionTraits>(
      string, options, expect_result, expect_value);
}

TEST(SymbolicConstantsMach, StringToException) {
  for (size_t option_index = 0;
       option_index < arraysize(kNormalOptions);
       ++option_index) {
    SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
    StringToSymbolicConstantOptions options = kNormalOptions[option_index];
    for (size_t index = 0; index < arraysize(kExceptionTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      exception_type_t exception = kExceptionTestData[index].exception;
      {
        SCOPED_TRACE("full_name");
        TestStringToException(kExceptionTestData[index].full_name,
                              options,
                              options & kAllowFullName,
                              exception);
      }
      {
        SCOPED_TRACE("short_name");
        TestStringToException(kExceptionTestData[index].short_name,
                              options,
                              options & kAllowShortName,
                              exception);
      }
      {
        SCOPED_TRACE("number");
        std::string number_string = base::StringPrintf("%d", exception);
        TestStringToException(
            number_string, options, options & kAllowNumber, exception);
      }
    }

    const char* const kNegativeTestData[] = {
        "EXC_CRASH ",
        " EXC_BAD_INSTRUCTION",
        "CRASH ",
        " BAD_INSTRUCTION",
        "EXC_EXC_BAD_ACCESS",
        "EXC_SOFTWARES",
        "SOFTWARES",
        "EXC_JUNK",
        "random",
        "",
    };

    for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      TestStringToException(kNegativeTestData[index], options, false, 0);
    }

    const struct {
      const char* string;
      size_t length;
    } kNULTestData[] = {
        NUL_TEST_DATA("\0EXC_ARITHMETIC"),
        NUL_TEST_DATA("EXC_\0ARITHMETIC"),
        NUL_TEST_DATA("EXC_ARITH\0METIC"),
        NUL_TEST_DATA("EXC_ARITHMETIC\0"),
        NUL_TEST_DATA("\0ARITHMETIC"),
        NUL_TEST_DATA("ARITH\0METIC"),
        NUL_TEST_DATA("ARITHMETIC\0"),
        NUL_TEST_DATA("\0003"),
        NUL_TEST_DATA("3\0"),
        NUL_TEST_DATA("1\0002"),
    };

    for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      base::StringPiece string(kNULTestData[index].string,
                               kNULTestData[index].length);
      TestStringToException(string, options, false, 0);
    }
  }

  // Ensure that a NUL is not required at the end of the string.
  {
    SCOPED_TRACE("trailing_NUL_full");
    TestStringToException(base::StringPiece("EXC_BREAKPOINTED", 14),
                          kAllowFullName,
                          true,
                          EXC_BREAKPOINT);
  }
  {
    SCOPED_TRACE("trailing_NUL_short");
    TestStringToException(base::StringPiece("BREAKPOINTED", 10),
                          kAllowShortName,
                          true,
                          EXC_BREAKPOINT);
  }
}

const struct {
  exception_mask_t exception_mask;
  const char* full_name;
  const char* short_name;
} kExceptionMaskTestData[] = {
    {EXC_MASK_BAD_ACCESS, "EXC_MASK_BAD_ACCESS", "BAD_ACCESS"},
    {EXC_MASK_BAD_INSTRUCTION, "EXC_MASK_BAD_INSTRUCTION", "BAD_INSTRUCTION"},
    {EXC_MASK_ARITHMETIC, "EXC_MASK_ARITHMETIC", "ARITHMETIC"},
    {EXC_MASK_EMULATION, "EXC_MASK_EMULATION", "EMULATION"},
    {EXC_MASK_SOFTWARE, "EXC_MASK_SOFTWARE", "SOFTWARE"},
    {EXC_MASK_MACH_SYSCALL, "EXC_MASK_MACH_SYSCALL", "MACH_SYSCALL"},
    {EXC_MASK_RPC_ALERT, "EXC_MASK_RPC_ALERT", "RPC_ALERT"},
    {EXC_MASK_CRASH, "EXC_MASK_CRASH", "CRASH"},
    {EXC_MASK_RESOURCE, "EXC_MASK_RESOURCE", "RESOURCE"},
    {EXC_MASK_GUARD, "EXC_MASK_GUARD", "GUARD"},
    {0x1, "0x1", "0x1"},
    {EXC_MASK_CRASH | 0x1, "EXC_MASK_CRASH|0x1", "CRASH|0x1"},
    {EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC |
         EXC_MASK_EMULATION |
         EXC_MASK_SOFTWARE |
         EXC_MASK_BREAKPOINT |
         EXC_MASK_SYSCALL |
         EXC_MASK_MACH_SYSCALL |
         EXC_MASK_RPC_ALERT,
     "EXC_MASK_BAD_ACCESS|EXC_MASK_BAD_INSTRUCTION|EXC_MASK_ARITHMETIC|"
     "EXC_MASK_EMULATION|EXC_MASK_SOFTWARE|EXC_MASK_BREAKPOINT|"
     "EXC_MASK_SYSCALL|EXC_MASK_MACH_SYSCALL|EXC_MASK_RPC_ALERT",
     "BAD_ACCESS|BAD_INSTRUCTION|ARITHMETIC|EMULATION|SOFTWARE|BREAKPOINT|"
     "SYSCALL|MACH_SYSCALL|RPC_ALERT"},
    {EXC_MASK_RESOURCE | EXC_MASK_GUARD,
     "EXC_MASK_RESOURCE|EXC_MASK_GUARD",
     "RESOURCE|GUARD"},
};

struct ConvertExceptionMaskTraits {
  using ValueType = exception_mask_t;
  static std::string SomethingToString(
      ValueType value,
      SymbolicConstantToStringOptions options) {
    return ExceptionMaskToString(value, options);
  }
  static bool StringToSomething(const base::StringPiece& string,
                                StringToSymbolicConstantOptions options,
                                ValueType* value) {
    return StringToExceptionMask(string, options, value);
  }
  static const char kValueName[];
};
const char ConvertExceptionMaskTraits::kValueName[] = "exception_mask";

void TestExceptionMaskToString(exception_mask_t value,
                               const char* expect_full,
                               const char* expect_short) {
  return TestSomethingToString<ConvertExceptionMaskTraits>(
      value, expect_full, expect_short);
}

TEST(SymbolicConstantsMach, ExceptionMaskToString) {
  for (size_t index = 0; index < arraysize(kExceptionMaskTestData); ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestExceptionMaskToString(kExceptionMaskTestData[index].exception_mask,
                              kExceptionMaskTestData[index].full_name,
                              kExceptionMaskTestData[index].short_name);
  }

  // Test kUseOr handling.
  EXPECT_TRUE(ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                    kUseFullName).empty());
  EXPECT_TRUE(ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                    kUseShortName).empty());
  EXPECT_EQ("0x1400",
            ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                  kUseFullName | kUnknownIsNumeric));
  EXPECT_EQ("0x1400",
            ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                  kUseShortName | kUnknownIsNumeric));
  EXPECT_EQ("EXC_MASK_CRASH|EXC_MASK_GUARD",
            ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                  kUseFullName | kUseOr));
  EXPECT_EQ("CRASH|GUARD",
            ExceptionMaskToString(EXC_MASK_CRASH | EXC_MASK_GUARD,
                                  kUseShortName | kUseOr));
}

void TestStringToExceptionMask(const base::StringPiece& string,
                               StringToSymbolicConstantOptions options,
                               bool expect_result,
                               exception_mask_t expect_value) {
  return TestStringToSomething<ConvertExceptionMaskTraits>(
      string, options, expect_result, expect_value);
}

TEST(SymbolicConstantsMach, StringToExceptionMask) {
  // Don’t use kNormalOptions, because kAllowOr needs to be tested.
  const StringToSymbolicConstantOptions kOptions[] = {
      0,
      kAllowFullName,
      kAllowShortName,
      kAllowFullName | kAllowShortName,
      kAllowNumber,
      kAllowFullName | kAllowNumber,
      kAllowShortName | kAllowNumber,
      kAllowFullName | kAllowShortName | kAllowNumber,
      kAllowOr,
      kAllowFullName | kAllowOr,
      kAllowShortName | kAllowOr,
      kAllowFullName | kAllowShortName | kAllowOr,
      kAllowNumber | kAllowOr,
      kAllowFullName | kAllowNumber | kAllowOr,
      kAllowShortName | kAllowNumber | kAllowOr,
      kAllowFullName | kAllowShortName | kAllowNumber | kAllowOr,
  };

  for (size_t option_index = 0;
       option_index < arraysize(kOptions);
       ++option_index) {
    SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
    StringToSymbolicConstantOptions options = kOptions[option_index];
    for (size_t index = 0; index < arraysize(kExceptionMaskTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      exception_mask_t exception_mask =
          kExceptionMaskTestData[index].exception_mask;
      {
        SCOPED_TRACE("full_name");
        base::StringPiece full_name(kExceptionMaskTestData[index].full_name);
        bool has_number = full_name.find("0x", 0) != base::StringPiece::npos;
        bool has_or = full_name.find('|', 0) != base::StringPiece::npos;
        bool allowed_characteristics =
            (has_number ? (options & kAllowNumber) : true) &&
            (has_or ? (options & kAllowOr) : true);
        bool is_number = full_name.compare("0x1") == 0;
        bool expect_valid =
            ((options & kAllowFullName) && allowed_characteristics) ||
            ((options & kAllowNumber) && is_number);
        TestStringToExceptionMask(
            full_name, options, expect_valid, exception_mask);
      }
      {
        SCOPED_TRACE("short_name");
        base::StringPiece short_name(kExceptionMaskTestData[index].short_name);
        bool has_number = short_name.find("0x", 0) != base::StringPiece::npos;
        bool has_or = short_name.find('|', 0) != base::StringPiece::npos;
        bool allowed_characteristics =
            (has_number ? (options & kAllowNumber) : true) &&
            (has_or ? (options & kAllowOr) : true);
        bool is_number = short_name.compare("0x1") == 0;
        bool expect_valid =
            ((options & kAllowShortName) && allowed_characteristics) ||
            ((options & kAllowNumber) && is_number);
        TestStringToExceptionMask(
            short_name, options, expect_valid, exception_mask);
      }
    }

    const char* const kNegativeTestData[] = {
        "EXC_MASK_CRASH ",
        " EXC_MASK_BAD_INSTRUCTION",
        "EXC_MASK_EXC_MASK_BAD_ACCESS",
        "EXC_MASK_SOFTWARES",
        "EXC_MASK_JUNK",
        "EXC_GUARD",
        "EXC_ARITHMETIC|EXC_FAKE",
        "ARITHMETIC|FAKE",
        "FAKE|ARITHMETIC",
        "EXC_FAKE|EXC_ARITHMETIC",
        "random",
        "",
    };

    for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      TestStringToExceptionMask(kNegativeTestData[index], options, false, 0);
    }

    const struct {
      const char* string;
      size_t length;
    } kNULTestData[] = {
        NUL_TEST_DATA("\0EXC_MASK_ARITHMETIC"),
        NUL_TEST_DATA("EXC_\0MASK_ARITHMETIC"),
        NUL_TEST_DATA("EXC_MASK_\0ARITHMETIC"),
        NUL_TEST_DATA("EXC_MASK_ARITH\0METIC"),
        NUL_TEST_DATA("EXC_MASK_ARITHMETIC\0"),
        NUL_TEST_DATA("\0ARITHMETIC"),
        NUL_TEST_DATA("ARITH\0METIC"),
        NUL_TEST_DATA("ARITHMETIC\0"),
        NUL_TEST_DATA("\0003"),
        NUL_TEST_DATA("3\0"),
        NUL_TEST_DATA("1\0002"),
        NUL_TEST_DATA("EXC_MASK_ARITHMETIC\0|EXC_MASK_EMULATION"),
        NUL_TEST_DATA("EXC_MASK_ARITHMETIC|\0EXC_MASK_EMULATION"),
        NUL_TEST_DATA("ARITHMETIC\0|EMULATION"),
        NUL_TEST_DATA("ARITHMETIC|\0EMULATION"),
    };

    for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      base::StringPiece string(kNULTestData[index].string,
                               kNULTestData[index].length);
      TestStringToExceptionMask(string, options, false, 0);
    }
  }

  const struct {
    const char* string;
    StringToSymbolicConstantOptions options;
    exception_mask_t mask;
  } kNonCanonicalTestData[] = {
      {"EXC_MASK_ALL", kAllowFullName, ExcMaskAll()},
      {"ALL", kAllowShortName, ExcMaskAll()},
      {"EXC_MASK_ALL|EXC_MASK_CRASH",
       kAllowFullName | kAllowOr,
       ExcMaskAll() | EXC_MASK_CRASH},
      {"ALL|CRASH",
       kAllowShortName | kAllowOr,
       ExcMaskAll() | EXC_MASK_CRASH},
      {"EXC_MASK_BAD_INSTRUCTION|EXC_MASK_BAD_ACCESS",
       kAllowFullName | kAllowOr,
       EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION},
      {"EMULATION|ARITHMETIC",
       kAllowShortName | kAllowOr,
       EXC_MASK_ARITHMETIC | EXC_MASK_EMULATION},
      {"EXC_MASK_SOFTWARE|BREAKPOINT",
       kAllowFullName | kAllowShortName | kAllowOr,
       EXC_MASK_SOFTWARE | EXC_MASK_BREAKPOINT},
      {"SYSCALL|0x100",
       kAllowShortName | kAllowNumber | kAllowOr,
       EXC_MASK_SYSCALL | 0x100},
    };

  for (size_t index = 0; index < arraysize(kNonCanonicalTestData); ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestStringToExceptionMask(kNonCanonicalTestData[index].string,
                              kNonCanonicalTestData[index].options,
                              true,
                              kNonCanonicalTestData[index].mask);
  }

  // Ensure that a NUL is not required at the end of the string.
  {
    SCOPED_TRACE("trailing_NUL_full");
    TestStringToExceptionMask(base::StringPiece("EXC_MASK_BREAKPOINTED", 19),
                              kAllowFullName,
                              true,
                              EXC_MASK_BREAKPOINT);
  }
  {
    SCOPED_TRACE("trailing_NUL_short");
    TestStringToExceptionMask(base::StringPiece("BREAKPOINTED", 10),
                              kAllowShortName,
                              true,
                              EXC_MASK_BREAKPOINT);
  }
}

const struct {
  exception_behavior_t behavior;
  const char* full_name;
  const char* short_name;
} kExceptionBehaviorTestData[] = {
    {EXCEPTION_DEFAULT, "EXCEPTION_DEFAULT", "DEFAULT"},
    {EXCEPTION_STATE, "EXCEPTION_STATE", "STATE"},
    {EXCEPTION_STATE_IDENTITY, "EXCEPTION_STATE_IDENTITY", "STATE_IDENTITY"},
    {implicit_cast<exception_behavior_t>(EXCEPTION_DEFAULT |
                                         MACH_EXCEPTION_CODES),
     "EXCEPTION_DEFAULT|MACH_EXCEPTION_CODES",
     "DEFAULT|MACH"},
    {implicit_cast<exception_behavior_t>(EXCEPTION_STATE |
                                         MACH_EXCEPTION_CODES),
     "EXCEPTION_STATE|MACH_EXCEPTION_CODES",
     "STATE|MACH"},
    {implicit_cast<exception_behavior_t>(EXCEPTION_STATE_IDENTITY |
                                         MACH_EXCEPTION_CODES),
     "EXCEPTION_STATE_IDENTITY|MACH_EXCEPTION_CODES",
     "STATE_IDENTITY|MACH"},
};

struct ConvertExceptionBehaviorTraits {
  using ValueType = exception_behavior_t;
  static std::string SomethingToString(
      ValueType value,
      SymbolicConstantToStringOptions options) {
    return ExceptionBehaviorToString(value, options);
  }
  static bool StringToSomething(const base::StringPiece& string,
                                StringToSymbolicConstantOptions options,
                                ValueType* value) {
    return StringToExceptionBehavior(string, options, value);
  }
  static const char kValueName[];
};
const char ConvertExceptionBehaviorTraits::kValueName[] = "behavior";

void TestExceptionBehaviorToString(exception_behavior_t value,
                                   const char* expect_full,
                                   const char* expect_short) {
  return TestSomethingToString<ConvertExceptionBehaviorTraits>(
      value, expect_full, expect_short);
}

TEST(SymbolicConstantsMach, ExceptionBehaviorToString) {
  for (size_t index = 0;
       index < arraysize(kExceptionBehaviorTestData);
       ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestExceptionBehaviorToString(kExceptionBehaviorTestData[index].behavior,
                                  kExceptionBehaviorTestData[index].full_name,
                                  kExceptionBehaviorTestData[index].short_name);
  }

  for (exception_behavior_t behavior = 0; behavior < 8; ++behavior) {
    SCOPED_TRACE(base::StringPrintf("behavior %d", behavior));
    exception_behavior_t behavior_mach = behavior | MACH_EXCEPTION_CODES;
    if (behavior > 0 && behavior <= EXCEPTION_STATE_IDENTITY) {
      TestExceptionBehaviorToString(behavior, "", "");
      TestExceptionBehaviorToString(behavior_mach, "", "");
    } else {
      TestExceptionBehaviorToString(behavior, nullptr, nullptr);
      TestExceptionBehaviorToString(behavior_mach, nullptr, nullptr);
    }
  }
}

void TestStringToExceptionBehavior(const base::StringPiece& string,
                                   StringToSymbolicConstantOptions options,
                                   bool expect_result,
                                   exception_behavior_t expect_value) {
  return TestStringToSomething<ConvertExceptionBehaviorTraits>(
      string, options, expect_result, expect_value);
}

TEST(SymbolicConstantsMach, StringToExceptionBehavior) {
  for (size_t option_index = 0;
       option_index < arraysize(kNormalOptions);
       ++option_index) {
    SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
    StringToSymbolicConstantOptions options = kNormalOptions[option_index];
    for (size_t index = 0;
         index < arraysize(kExceptionBehaviorTestData);
         ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      exception_behavior_t behavior =
          kExceptionBehaviorTestData[index].behavior;
      {
        SCOPED_TRACE("full_name");
        TestStringToExceptionBehavior(
            kExceptionBehaviorTestData[index].full_name,
            options,
            options & kAllowFullName,
            behavior);
      }
      {
        SCOPED_TRACE("short_name");
        TestStringToExceptionBehavior(
            kExceptionBehaviorTestData[index].short_name,
            options,
            options & kAllowShortName,
            behavior);
      }
      {
        SCOPED_TRACE("number");
        std::string number_string = base::StringPrintf("0x%x", behavior);
        TestStringToExceptionBehavior(
            number_string, options, options & kAllowNumber, behavior);
      }
    }

    const char* const kNegativeTestData[] = {
        "EXCEPTION_DEFAULT ",
        " EXCEPTION_STATE",
        "EXCEPTION_EXCEPTION_STATE_IDENTITY",
        "EXCEPTION_DEFAULTS",
        "EXCEPTION_JUNK",
        "random",
        "MACH_EXCEPTION_CODES",
        "MACH",
        "MACH_EXCEPTION_CODES|MACH_EXCEPTION_CODES",
        "MACH_EXCEPTION_CODES|EXCEPTION_NONEXISTENT",
        "MACH|junk",
        "EXCEPTION_DEFAULT|EXCEPTION_STATE",
        "1|2",
        "",
    };

    for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      TestStringToExceptionBehavior(
          kNegativeTestData[index], options, false, 0);
    }

    const struct {
      const char* string;
      size_t length;
    } kNULTestData[] = {
        NUL_TEST_DATA("\0EXCEPTION_STATE_IDENTITY"),
        NUL_TEST_DATA("EXCEPTION_\0STATE_IDENTITY"),
        NUL_TEST_DATA("EXCEPTION_STATE\0_IDENTITY"),
        NUL_TEST_DATA("EXCEPTION_STATE_IDENTITY\0"),
        NUL_TEST_DATA("\0STATE_IDENTITY"),
        NUL_TEST_DATA("STATE\0_IDENTITY"),
        NUL_TEST_DATA("STATE_IDENTITY\0"),
        NUL_TEST_DATA("\0003"),
        NUL_TEST_DATA("3\0"),
        NUL_TEST_DATA("0x8000000\0001"),
        NUL_TEST_DATA("EXCEPTION_STATE_IDENTITY\0|MACH_EXCEPTION_CODES"),
        NUL_TEST_DATA("EXCEPTION_STATE_IDENTITY|\0MACH_EXCEPTION_CODES"),
        NUL_TEST_DATA("STATE_IDENTITY\0|MACH"),
        NUL_TEST_DATA("STATE_IDENTITY|\0MACH"),
    };

    for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      base::StringPiece string(kNULTestData[index].string,
                               kNULTestData[index].length);
      TestStringToExceptionBehavior(string, options, false, 0);
    }
  }

  const struct {
    const char* string;
    StringToSymbolicConstantOptions options;
    exception_behavior_t behavior;
  } kNonCanonicalTestData[] = {
      {"MACH_EXCEPTION_CODES|EXCEPTION_STATE_IDENTITY",
       kAllowFullName,
       implicit_cast<exception_behavior_t>(EXCEPTION_STATE_IDENTITY |
                                           MACH_EXCEPTION_CODES)},
      {"MACH|STATE_IDENTITY",
       kAllowShortName,
       implicit_cast<exception_behavior_t>(EXCEPTION_STATE_IDENTITY |
                                           MACH_EXCEPTION_CODES)},
      {"MACH_EXCEPTION_CODES|STATE",
       kAllowFullName | kAllowShortName,
       implicit_cast<exception_behavior_t>(EXCEPTION_STATE |
                                           MACH_EXCEPTION_CODES)},
      {"MACH|EXCEPTION_STATE",
       kAllowFullName | kAllowShortName,
       implicit_cast<exception_behavior_t>(EXCEPTION_STATE |
                                           MACH_EXCEPTION_CODES)},
      {"3|MACH_EXCEPTION_CODES",
       kAllowFullName | kAllowNumber,
       implicit_cast<exception_behavior_t>(MACH_EXCEPTION_CODES | 3)},
      {"MACH|0x2",
       kAllowShortName | kAllowNumber,
       implicit_cast<exception_behavior_t>(MACH_EXCEPTION_CODES | 0x2)},
  };

  for (size_t index = 0; index < arraysize(kNonCanonicalTestData); ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestStringToExceptionBehavior(kNonCanonicalTestData[index].string,
                                  kNonCanonicalTestData[index].options,
                                  true,
                                  kNonCanonicalTestData[index].behavior);
  }

  // Ensure that a NUL is not required at the end of the string.
  {
    SCOPED_TRACE("trailing_NUL_full");
    TestStringToExceptionBehavior(base::StringPiece("EXCEPTION_DEFAULTS", 17),
                                  kAllowFullName,
                                  true,
                                  EXCEPTION_DEFAULT);
  }
  {
    SCOPED_TRACE("trailing_NUL_short");
    TestStringToExceptionBehavior(base::StringPiece("DEFAULTS", 7),
                                  kAllowShortName,
                                  true,
                                  EXCEPTION_DEFAULT);
  }
  {
    SCOPED_TRACE("trailing_NUL_full_mach");
    base::StringPiece string("EXCEPTION_DEFAULT|MACH_EXCEPTION_CODESS", 38);
    TestStringToExceptionBehavior(string,
                                  kAllowFullName | kAllowOr,
                                  true,
                                  EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES);
  }
  {
    SCOPED_TRACE("trailing_NUL_short_mach");
    TestStringToExceptionBehavior(base::StringPiece("DEFAULT|MACH_", 12),
                                  kAllowShortName | kAllowOr,
                                  true,
                                  EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES);
  }
}

const struct {
  thread_state_flavor_t flavor;
  const char* full_name;
  const char* short_name;
} kThreadStateFlavorTestData[] = {
    {THREAD_STATE_NONE, "THREAD_STATE_NONE", "NONE"},
    {THREAD_STATE_FLAVOR_LIST, "THREAD_STATE_FLAVOR_LIST", "FLAVOR_LIST"},
    {THREAD_STATE_FLAVOR_LIST_NEW,
     "THREAD_STATE_FLAVOR_LIST_NEW",
     "FLAVOR_LIST_NEW"},
    {THREAD_STATE_FLAVOR_LIST_10_9,
     "THREAD_STATE_FLAVOR_LIST_10_9",
     "FLAVOR_LIST_10_9"},
#if defined(__i386__) || defined(__x86_64__)
    {x86_THREAD_STATE32, "x86_THREAD_STATE32", "THREAD32"},
    {x86_FLOAT_STATE32, "x86_FLOAT_STATE32", "FLOAT32"},
    {x86_EXCEPTION_STATE32, "x86_EXCEPTION_STATE32", "EXCEPTION32"},
    {x86_THREAD_STATE64, "x86_THREAD_STATE64", "THREAD64"},
    {x86_FLOAT_STATE64, "x86_FLOAT_STATE64", "FLOAT64"},
    {x86_EXCEPTION_STATE64, "x86_EXCEPTION_STATE64", "EXCEPTION64"},
    {x86_THREAD_STATE, "x86_THREAD_STATE", "THREAD"},
    {x86_FLOAT_STATE, "x86_FLOAT_STATE", "FLOAT"},
    {x86_EXCEPTION_STATE, "x86_EXCEPTION_STATE", "EXCEPTION"},
    {x86_DEBUG_STATE32, "x86_DEBUG_STATE32", "DEBUG32"},
    {x86_DEBUG_STATE64, "x86_DEBUG_STATE64", "DEBUG64"},
    {x86_DEBUG_STATE, "x86_DEBUG_STATE", "DEBUG"},
    {14, "x86_SAVED_STATE32", "SAVED32"},
    {15, "x86_SAVED_STATE64", "SAVED64"},
    {x86_AVX_STATE32, "x86_AVX_STATE32", "AVX32"},
    {x86_AVX_STATE64, "x86_AVX_STATE64", "AVX64"},
    {x86_AVX_STATE, "x86_AVX_STATE", "AVX"},
#elif defined(__ppc__) || defined(__ppc64__)
    {PPC_THREAD_STATE, "PPC_THREAD_STATE", "THREAD"},
    {PPC_FLOAT_STATE, "PPC_FLOAT_STATE", "FLOAT"},
    {PPC_EXCEPTION_STATE, "PPC_EXCEPTION_STATE", "EXCEPTION"},
    {PPC_VECTOR_STATE, "PPC_VECTOR_STATE", "VECTOR"},
    {PPC_THREAD_STATE64, "PPC_THREAD_STATE64", "THREAD64"},
    {PPC_EXCEPTION_STATE64, "PPC_EXCEPTION_STATE64", "EXCEPTION64"},
#elif defined(__arm__) || defined(__arm64__)
    {ARM_THREAD_STATE, "ARM_THREAD_STATE", "THREAD"},
    {ARM_VFP_STATE, "ARM_VFP_STATE", "VFP"},
    {ARM_EXCEPTION_STATE, "ARM_EXCEPTION_STATE", "EXCEPTION"},
    {ARM_DEBUG_STATE, "ARM_DEBUG_STATE", "DEBUG"},
    {ARM_THREAD_STATE64, "ARM_THREAD_STATE64", "THREAD64"},
    {ARM_EXCEPTION_STATE64, "ARM_EXCEPTION_STATE64", "EXCEPTION64"},
    {ARM_THREAD_STATE32, "ARM_THREAD_STATE32", "THREAD32"},
    {ARM_DEBUG_STATE32, "ARM_DEBUG_STATE32", "DEBUG32"},
    {ARM_DEBUG_STATE64, "ARM_DEBUG_STATE64", "DEBUG64"},
    {ARM_NEON_STATE, "ARM_NEON_STATE", "NEON"},
    {ARM_NEON_STATE64, "ARM_NEON_STATE64", "NEON64"},
#endif
};

struct ConvertThreadStateFlavorTraits {
  using ValueType = thread_state_flavor_t;
  static std::string SomethingToString(
      ValueType value,
      SymbolicConstantToStringOptions options) {
    return ThreadStateFlavorToString(value, options);
  }
  static bool StringToSomething(const base::StringPiece& string,
                                StringToSymbolicConstantOptions options,
                                ValueType* value) {
    return StringToThreadStateFlavor(string, options, value);
  }
  static const char kValueName[];
};
const char ConvertThreadStateFlavorTraits::kValueName[] = "flavor";

void TestThreadStateFlavorToString(exception_type_t value,
                                   const char* expect_full,
                                   const char* expect_short) {
  return TestSomethingToString<ConvertThreadStateFlavorTraits>(
      value, expect_full, expect_short);
}

TEST(SymbolicConstantsMach, ThreadStateFlavorToString) {
  for (size_t index = 0;
       index < arraysize(kThreadStateFlavorTestData);
       ++index) {
    SCOPED_TRACE(base::StringPrintf("index %zu", index));
    TestThreadStateFlavorToString(kThreadStateFlavorTestData[index].flavor,
                                  kThreadStateFlavorTestData[index].full_name,
                                  kThreadStateFlavorTestData[index].short_name);
  }

  for (thread_state_flavor_t flavor = 0; flavor < 136; ++flavor) {
    SCOPED_TRACE(base::StringPrintf("flavor %d", flavor));

    // Flavor numbers appear to be assigned somewhat haphazardly, especially on
    // certain architectures. The conditional should match flavors that
    // ThreadStateFlavorToString() knows how to convert.
    if (
#if defined(__i386__) || defined(__x86_64__)
        flavor <= x86_AVX_STATE
#elif defined(__ppc__) || defined(__ppc64__)
        flavor <= THREAD_STATE_NONE
#elif defined(__arm__) || defined(__arm64__)
        (flavor <= ARM_EXCEPTION_STATE64 || flavor == ARM_THREAD_STATE32 ||
         (flavor >= ARM_DEBUG_STATE32 && flavor <= ARM_NEON_STATE64))
#endif
        ||
        flavor == THREAD_STATE_FLAVOR_LIST_NEW ||
        flavor == THREAD_STATE_FLAVOR_LIST_10_9) {
      TestThreadStateFlavorToString(flavor, "", "");
    } else {
      TestThreadStateFlavorToString(flavor, nullptr, nullptr);
    }
  }
}

void TestStringToThreadStateFlavor(const base::StringPiece& string,
                                   StringToSymbolicConstantOptions options,
                                   bool expect_result,
                                   thread_state_flavor_t expect_value) {
  return TestStringToSomething<ConvertThreadStateFlavorTraits>(
      string, options, expect_result, expect_value);
}

TEST(SymbolicConstantsMach, StringToThreadStateFlavor) {
  for (size_t option_index = 0;
       option_index < arraysize(kNormalOptions);
       ++option_index) {
    SCOPED_TRACE(base::StringPrintf("option_index %zu", option_index));
    StringToSymbolicConstantOptions options = kNormalOptions[option_index];
    for (size_t index = 0;
         index < arraysize(kThreadStateFlavorTestData);
         ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      thread_state_flavor_t flavor = kThreadStateFlavorTestData[index].flavor;
      {
        SCOPED_TRACE("full_name");
        TestStringToThreadStateFlavor(
            kThreadStateFlavorTestData[index].full_name,
            options,
            options & kAllowFullName,
            flavor);
      }
      {
        SCOPED_TRACE("short_name");
        TestStringToThreadStateFlavor(
            kThreadStateFlavorTestData[index].short_name,
            options,
            options & kAllowShortName,
            flavor);
      }
      {
        SCOPED_TRACE("number");
        std::string number_string = base::StringPrintf("%d", flavor);
        TestStringToThreadStateFlavor(
            number_string, options, options & kAllowNumber, flavor);
      }
    }

    const char* const kNegativeTestData[] = {
      "THREAD_STATE_NONE ",
      " THREAD_STATE_NONE",
      "NONE ",
      " NONE",
      "THREAD_STATE_THREAD_STATE_NONE",
      "THREAD_STATE_NONE_AT_ALL",
      "NONE_AT_ALL",
      "THREAD_STATE_JUNK",
      "JUNK",
      "random",
      " THREAD64",
      "THREAD64 ",
      "THREAD642",
      "",
#if defined(__i386__) || defined(__x86_64__)
      " x86_THREAD_STATE64",
      "x86_THREAD_STATE64 ",
      "x86_THREAD_STATE642",
      "x86_JUNK",
      "x86_JUNK_STATE32",
      "PPC_THREAD_STATE",
      "ARM_THREAD_STATE",
#elif defined(__ppc__) || defined(__ppc64__)
      " PPC_THREAD_STATE64",
      "PPC_THREAD_STATE64 ",
      "PPC_THREAD_STATE642",
      "PPC_JUNK",
      "PPC_JUNK_STATE32",
      "x86_THREAD_STATE",
      "ARM_THREAD_STATE",
#elif defined(__arm__) || defined(__arm64__)
      " ARM_THREAD_STATE64",
      "ARM_THREAD_STATE64 ",
      "ARM_THREAD_STATE642",
      "ARM_JUNK",
      "ARM_JUNK_STATE32",
      "x86_THREAD_STATE",
      "PPC_THREAD_STATE",
#endif
    };

    for (size_t index = 0; index < arraysize(kNegativeTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      TestStringToThreadStateFlavor(
          kNegativeTestData[index], options, false, 0);
    }

    const struct {
      const char* string;
      size_t length;
    } kNULTestData[] = {
        NUL_TEST_DATA("\0THREAD_STATE_NONE"),
        NUL_TEST_DATA("THREAD_\0STATE_NONE"),
        NUL_TEST_DATA("THREAD_STATE_\0NONE"),
        NUL_TEST_DATA("THREAD_STATE_NO\0NE"),
        NUL_TEST_DATA("THREAD_STATE_NONE\0"),
        NUL_TEST_DATA("\0NONE"),
        NUL_TEST_DATA("NO\0NE"),
        NUL_TEST_DATA("NONE\0"),
        NUL_TEST_DATA("\0THREAD_STATE_FLAVOR_LIST_NEW"),
        NUL_TEST_DATA("THREAD_STATE_\0FLAVOR_LIST_NEW"),
        NUL_TEST_DATA("THREAD_STATE_FLAVOR_LIST\0_NEW"),
        NUL_TEST_DATA("THREAD_STATE_FLAVOR_LIST_NEW\0"),
        NUL_TEST_DATA("\0FLAVOR_LIST_NEW"),
        NUL_TEST_DATA("FLAVOR_LIST\0_NEW"),
        NUL_TEST_DATA("FLAVOR_LIST_NEW\0"),
        NUL_TEST_DATA("\0THREAD"),
        NUL_TEST_DATA("THR\0EAD"),
        NUL_TEST_DATA("THREAD\0"),
        NUL_TEST_DATA("\0THREAD64"),
        NUL_TEST_DATA("THR\0EAD64"),
        NUL_TEST_DATA("THREAD\064"),
        NUL_TEST_DATA("THREAD64\0"),
        NUL_TEST_DATA("\0002"),
        NUL_TEST_DATA("2\0"),
        NUL_TEST_DATA("1\0002"),
#if defined(__i386__) || defined(__x86_64__)
        NUL_TEST_DATA("\0x86_THREAD_STATE64"),
        NUL_TEST_DATA("x86\0_THREAD_STATE64"),
        NUL_TEST_DATA("x86_\0THREAD_STATE64"),
        NUL_TEST_DATA("x86_THR\0EAD_STATE64"),
        NUL_TEST_DATA("x86_THREAD\0_STATE64"),
        NUL_TEST_DATA("x86_THREAD_\0STATE64"),
        NUL_TEST_DATA("x86_THREAD_STA\0TE64"),
        NUL_TEST_DATA("x86_THREAD_STATE\00064"),
        NUL_TEST_DATA("x86_THREAD_STATE64\0"),
#elif defined(__ppc__) || defined(__ppc64__)
        NUL_TEST_DATA("\0PPC_THREAD_STATE64"),
        NUL_TEST_DATA("PPC\0_THREAD_STATE64"),
        NUL_TEST_DATA("PPC_\0THREAD_STATE64"),
        NUL_TEST_DATA("PPC_THR\0EAD_STATE64"),
        NUL_TEST_DATA("PPC_THREAD\0_STATE64"),
        NUL_TEST_DATA("PPC_THREAD_\0STATE64"),
        NUL_TEST_DATA("PPC_THREAD_STA\0TE64"),
        NUL_TEST_DATA("PPC_THREAD_STATE\00064"),
#elif defined(__arm__) || defined(__arm64__)
        NUL_TEST_DATA("\0ARM_THREAD_STATE64"),
        NUL_TEST_DATA("ARM\0_THREAD_STATE64"),
        NUL_TEST_DATA("ARM_\0THREAD_STATE64"),
        NUL_TEST_DATA("ARM_THR\0EAD_STATE64"),
        NUL_TEST_DATA("ARM_THREAD\0_STATE64"),
        NUL_TEST_DATA("ARM_THREAD_\0STATE64"),
        NUL_TEST_DATA("ARM_THREAD_STA\0TE64"),
        NUL_TEST_DATA("ARM_THREAD_STATE\00064"),
#endif
    };

    for (size_t index = 0; index < arraysize(kNULTestData); ++index) {
      SCOPED_TRACE(base::StringPrintf("index %zu", index));
      base::StringPiece string(kNULTestData[index].string,
                               kNULTestData[index].length);
      TestStringToThreadStateFlavor(string, options, false, 0);
    }
  }

  // Ensure that a NUL is not required at the end of the string.
  {
    SCOPED_TRACE("trailing_NUL_full");
    TestStringToThreadStateFlavor(base::StringPiece("THREAD_STATE_NONER", 17),
                                  kAllowFullName,
                                  true,
                                  THREAD_STATE_NONE);
  }
  {
    SCOPED_TRACE("trailing_NUL_short");
    TestStringToThreadStateFlavor(base::StringPiece("NONER", 4),
                                  kAllowShortName,
                                  true,
                                  THREAD_STATE_NONE);
  }
  {
    SCOPED_TRACE("trailing_NUL_full_new");
    base::StringPiece string("THREAD_STATE_FLAVOR_LIST_NEWS", 28);
    TestStringToThreadStateFlavor(
        string, kAllowFullName, true, THREAD_STATE_FLAVOR_LIST_NEW);
  }
  {
    SCOPED_TRACE("trailing_NUL_short_new");
    TestStringToThreadStateFlavor(base::StringPiece("FLAVOR_LIST_NEWS", 15),
                                  kAllowShortName,
                                  true,
                                  THREAD_STATE_FLAVOR_LIST_NEW);
  }
}

}  // namespace
}  // namespace test
}  // namespace crashpad