DILTests.cpp

// Copyright 2020 Google LLC
//
// 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.

/// DIL TODO:
// * Fix errors in XFailed tests
// * Fix segfault errors in GTEST_SKIP tests
// * Implement interfaces for scoped, context, and separate parsing
//   and re-enable DISABLED_ tests

#include "lldb/API/SBError.h"
#include "lldb/lldb-enumerations.h"
#ifndef __EMSCRIPTEN__
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <unordered_map>

#include "TestingSupport/TestUtilities.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBType.h"
#include "Runner.h"
#include "Traits.h"
#endif

// DISALLOW_COPY_AND_ASSIGN is also defined in
// lldb/lldb-defines.h
#undef DISALLOW_COPY_AND_ASSIGN
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#ifndef __EMSCRIPTEN__

using ::testing::MakeMatcher;
using ::testing::Matcher;
using ::testing::MatcherInterface;
using ::testing::MatchResultListener;

struct EvalResult {
  lldb::SBError lldb_DIL_error;
  mutable lldb::SBValue lldb_DIL_value;
  mutable std::optional<lldb::SBValue> lldb_value;

  friend std::ostream &operator<<(std::ostream &os, const EvalResult &result) {
    auto maybe_null = [](const char *str) {
      return str == nullptr ? "NULL" : str;
    };

    os << "{ DIL: " << maybe_null(result.lldb_DIL_value.GetValue());

    if (result.lldb_value.has_value()) {
      os << ", lldb: " << maybe_null(result.lldb_value.value().GetValue());
    }
    os << " }";

    return os;
  }
};

struct CompiledExpr {
  // Unsupported
};

class EvaluatorHelper {
public:
  EvaluatorHelper(lldb::SBFrame frame, bool lldb, bool side_effects)
      : frame_(frame), lldb_(lldb) {}
  EvaluatorHelper(lldb::SBValue scope, bool lldb, bool side_effects)
      : scope_(scope), lldb_(lldb) {}

public:
  EvalResult Eval(const std::string &expr) {
    EvalResult ret;

    // lldb_eval::Options opts;
    // opts.allow_side_effects = side_effects_;

    if (scope_) {
      ret.lldb_DIL_error =
          lldb::SBError("Scope evaluation is not yet supported");
      // // Evaluate in the variable context.
      // ret.lldb_DIL_value = lldb_eval::EvaluateExpression(
      //     scope_, expr.c_str(), opts, ret.lldb_DIL_error);

      if (lldb_) {
        ret.lldb_value = scope_.EvaluateExpression(expr.c_str());
      }
    } else {
      // Evaluate in the frame context.
      ret.lldb_DIL_value =
          frame_.EvaluateExpressionViaDIL(expr.c_str(), lldb::eNoDynamicValues);
      if (!ret.lldb_DIL_value.GetError().Success())
        ret.lldb_DIL_error = ret.lldb_DIL_value.GetError();
      // ret.lldb_DIL_value = lldb_eval::EvaluateExpression(
      //     frame_, expr.c_str(), opts, ret.lldb_DIL_error);

      if (lldb_) {
        ret.lldb_value = frame_.EvaluateExpression(expr.c_str());
      }
    }

    return ret;
  }

  EvalResult Eval(CompiledExpr compiled_expr) {
    assert(scope_ && "compiled expression requires a value context");

    EvalResult ret;
    ret.lldb_DIL_error = lldb::SBError("Separate parsing is not yet supported");
    // ret.lldb_DIL_value = lldb_eval::EvaluateExpression(scope_, compiled_expr,
    //                                                     ret.lldb_DIL_error);
    return ret;
  }

  EvalResult
  EvalWithContext(const std::string &expr,
                  const std::unordered_map<std::string, lldb::SBValue> &vars) {
    EvalResult ret;

    // std::vector<lldb_eval::ContextVariable> ctx_vec;
    // ctx_vec.reserve(vars.size());
    // for (const auto& [name, value] : vars) {
    //   ctx_vec.push_back({name.c_str(), value});
    // }

    // lldb_eval::Options opts;
    // opts.allow_side_effects = side_effects_;
    // opts.context_vars = {ctx_vec.data(), ctx_vec.size()};

    if (scope_) {
      // Evaluate in the variable context.
      ret.lldb_DIL_error =
          lldb::SBError("Evaluation with context is not yet supported");
      //   ret.lldb_DIL_value = lldb_eval::EvaluateExpression(
      //       scope_, expr.c_str(), opts, ret.lldb_DIL_error);

      if (lldb_) {
        ret.lldb_value = scope_.EvaluateExpression(expr.c_str());
      }
    } else {
      // Evaluate in the frame context.
      ret.lldb_DIL_error =
          lldb::SBError("Evaluation with context is not yet supported");
      //   ret.lldb_DIL_value = lldb_eval::EvaluateExpression(
      //       frame_, expr.c_str(), opts, ret.lldb_DIL_error);

      if (lldb_) {
        ret.lldb_value = frame_.EvaluateExpression(expr.c_str());
      }
    }

    return ret;
  }

  EvalResult
  EvalWithContext(CompiledExpr compiled_expr,
                  const std::unordered_map<std::string, lldb::SBValue> &vars) {
    assert(scope_ && "compiled expression requires a value context");

    EvalResult ret;
    ret.lldb_DIL_error = lldb::SBError("Separate parsing is not yet supported");
    return ret;

    // std::vector<lldb_eval::ContextVariable> ctx_vec;
    // ctx_vec.reserve(vars.size());
    // for (const auto& [name, value] : vars) {
    //   ctx_vec.push_back({name.c_str(), value});
    // }
    // lldb_eval::ContextVariableList context_vars{ctx_vec.data(),
    // ctx_vec.size()};

    // EvalResult ret;
    // ret.lldb_DIL_value = lldb_eval::EvaluateExpression(
    //     scope_, compiled_expr, context_vars, ret.lldb_DIL_error);
    // return ret;
  }

  CompiledExpr Compile(const std::string &expr, lldb::SBError &error) {
    assert(scope_ && "compiling an expression requires a type context");

    error = lldb::SBError("Separate parsing is not yet supported");
    return CompiledExpr();
    // lldb_eval::Options opts;
    // opts.allow_side_effects = side_effects_;
    // return lldb_eval::CompileExpression(scope_.GetTarget(), scope_.GetType(),
    //                                     expr.c_str(), opts, error);
  }

  CompiledExpr
  CompileWithContext(const std::string &expr,
                     const std::unordered_map<std::string, lldb::SBType> &args,
                     lldb::SBError &error) {
    assert(scope_ && "compiling an expression requires a type context");

    error = lldb::SBError("Separate parsing is not yet supported");
    return CompiledExpr();

    // std::vector<lldb_eval::ContextArgument> ctx_vec;
    // ctx_vec.reserve(args.size());
    // for (const auto& [name, type] : args) {
    //   ctx_vec.push_back({name.c_str(), type});
    // }

    // lldb_eval::Options opts;
    // opts.allow_side_effects = side_effects_;
    // opts.context_args = {ctx_vec.data(), ctx_vec.size()};

    // return lldb_eval::CompileExpression(scope_.GetTarget(), scope_.GetType(),
    //                                     expr.c_str(), opts, error);
  }

private:
  lldb::SBFrame frame_;
  lldb::SBValue scope_;
  bool lldb_;
  // bool side_effects_;
};
#endif

void PrintError(::testing::MatchResultListener *listener,
                const std::string &error) {
  *listener << "error:";
  // Print multiline errors on a separate line.
  if (error.find('\n') != std::string::npos) {
    *listener << "\n";
  } else {
    *listener << " ";
  }
  *listener << error;
}

#ifndef __EMSCRIPTEN__
class IsOkMatcher : public MatcherInterface<EvalResult> {
public:
  explicit IsOkMatcher(bool compare_types) : compare_types_(compare_types) {}

  bool MatchAndExplain(EvalResult result,
                       MatchResultListener *listener) const override {
    if (result.lldb_DIL_error.GetError()) {
      PrintError(listener, result.lldb_DIL_error.GetCString());
      return false;
    }

    std::string actual = result.lldb_DIL_value.GetValue();
    // Compare only if we tried to evaluate with LLDB.
    if (result.lldb_value.has_value()) {
      if (result.lldb_value.value().GetError().GetError()) {
        *listener << "values produced by DIL and LLDB don't match\n"
                  << "DIL: " << actual << "\n"
                  << "lldb     : "
                  << result.lldb_value.value().GetError().GetCString();
        return false;

      } else if (actual != result.lldb_value.value().GetValue()) {
        *listener << "values produced by DIL and LLDB don't match\n"
                  << "DIL: " << actual << "\n"
                  << "lldb     : " << result.lldb_value.value().GetValue();
        return false;
      }

      if (compare_types_) {
        const char *lldb_DIL_type =
            result.lldb_DIL_value.GetType().GetUnqualifiedType().GetName();
        const char *lldb_type =
            result.lldb_value.value().GetType().GetUnqualifiedType().GetName();
        if (strcmp(lldb_DIL_type, lldb_type) != 0) {
          *listener << "types produced by DIL and LLDB don't match\n"
                    << "DIL: " << lldb_DIL_type << "\n"
                    << "lldb     : " << lldb_type;
          return false;
        }
      }
    }

    return true;
  }

  void DescribeTo(std::ostream *os) const override {
    *os << "evaluates without an error and equals to LLDB";
  }

private:
  bool compare_types_;
};
#endif

Matcher<EvalResult> IsOk(bool compare_types = true) {
  return MakeMatcher(new IsOkMatcher(compare_types));
}

#ifndef __EMSCRIPTEN__
class IsEqualMatcher : public MatcherInterface<EvalResult> {
public:
  IsEqualMatcher(std::string value, bool compare_types)
      : value_(std::move(value)), compare_types_(compare_types) {}

public:
  bool MatchAndExplain(EvalResult result,
                       MatchResultListener *listener) const override {
    if (result.lldb_DIL_error.GetError()) {
      PrintError(listener, result.lldb_DIL_error.GetCString());
      return false;
    }

    std::string actual = result.lldb_DIL_value.GetValue();
    if (actual != value_) {
      *listener << "evaluated to '" << actual << "'";
      return false;
    }

    // Compare only if we tried to evaluate with LLDB.
    if (result.lldb_value.has_value()) {
      if (result.lldb_value.value().GetError().GetError()) {
        *listener << "values produced by DIL and LLDB don't match\n"
                  << "DIL: " << actual << "\n"
                  << "lldb     : "
                  << result.lldb_value.value().GetError().GetCString();
        return false;

      } else if (actual != result.lldb_value.value().GetValue()) {
        *listener << "values produced by DIL and LLDB don't match\n"
                  << "DIL: " << actual << "\n"
                  << "lldb     : " << result.lldb_value.value().GetValue();
        return false;
      }

      if (compare_types_) {
        const char *lldb_DIL_type =
            result.lldb_DIL_value.GetType().GetUnqualifiedType().GetName();
        const char *lldb_type =
            result.lldb_value.value().GetType().GetUnqualifiedType().GetName();
        if (strcmp(lldb_DIL_type, lldb_type) != 0) {
          *listener << "types produced by DIL and LLDB don't match\n"
                    << "DIL: " << lldb_DIL_type << "\n"
                    << "lldb     : " << lldb_type;
          return false;
        }
      }
    }
    return true;
  }

  void DescribeTo(std::ostream *os) const override {
    *os << "evaluates to '" << value_ << "'";
  }

private:
  std::string value_;
  bool compare_types_;
};
#endif

Matcher<EvalResult> IsEqual(std::string value, bool compare_types = true) {
  return MakeMatcher(new IsEqualMatcher(std::move(value), compare_types));
}

#ifndef __EMSCRIPTEN__
class IsErrorMatcher : public MatcherInterface<EvalResult> {
public:
  explicit IsErrorMatcher(std::string value) : value_(std::move(value)) {}

public:
  bool MatchAndExplain(EvalResult result,
                       MatchResultListener *listener) const override {
    if (!result.lldb_DIL_error.GetError()) {
      *listener << "evaluated to '" << result.lldb_DIL_value.GetValue() << "'";
      return false;
    }
    std::string message = result.lldb_DIL_error.GetCString();
    if (message.find(value_) == std::string::npos) {
      PrintError(listener, message);
      return false;
    }

    return true;
  }

  void DescribeTo(std::ostream *os) const override {
    *os << "evaluates with an error: '" << value_ << "'";
  }

private:
  std::string value_;
};
#endif

Matcher<EvalResult> IsError(std::string value) {
  return MakeMatcher(new IsErrorMatcher(std::move(value)));
}

static unsigned xfailed = 0;
template <typename InnerMatcher> Matcher<EvalResult> XFail(InnerMatcher m) {
  xfailed++;
  return Not(m);
}

#ifndef __EMSCRIPTEN__
class EvalTest : public ::testing::Test {
protected:
  static void SetUpTestSuite() { lldb::SBDebugger::Initialize(); }

  static void TearDownTestSuite() { lldb::SBDebugger::Terminate(); }

  void SetUp() {
    std::string test_name =
        ::testing::UnitTest::GetInstance()->current_test_info()->name();
    std::string break_line = "// BREAK(" + test_name + ")";

    std::string binary_path =
        lldb_private::GetInputFilePath("test_binary.bin");
    std::string source_path = lldb_private::GetInputFilePath("test_binary.cc");

    debugger_ = lldb::SBDebugger::Create(false);
    process_ =
        LaunchTestProgram(debugger_, source_path, binary_path, break_line);
    frame_ = process_.GetSelectedThread().GetSelectedFrame();
  }

  void TearDown() {
    if (xfailed != 0) {
      printf("[    !!    ] XFailed test cases: %d\n", xfailed);
      xfailed = 0;
    }
    process_.Destroy();
    lldb::SBDebugger::Destroy(debugger_);
  }

  EvalResult Eval(const std::string &expr) {
    return EvaluatorHelper(frame_, compare_with_lldb_, allow_side_effects_)
        .Eval(expr);
  }

  EvalResult
  EvalWithContext(const std::string &expr,
                  const std::unordered_map<std::string, lldb::SBValue> &vars) {
    return EvaluatorHelper(frame_, compare_with_lldb_, allow_side_effects_)
        .EvalWithContext(expr, vars);
  }

  EvaluatorHelper Scope(std::string scope) {
    // Resolve the scope variable (assume it's a local variable).
    lldb::SBValue scope_var = frame_.FindVariable(scope.c_str());
    return EvaluatorHelper(scope_var, compare_with_lldb_, allow_side_effects_);
  }

  bool CreateContextVariable(std::string type, std::string name, bool is_array,
                             std::string assignment) {
    std::string expr = type + " " + name + (is_array ? "[]" : "") + " = " +
                       assignment + "; " + name;
    lldb::SBValue value = frame_.EvaluateExpression(expr.c_str());
    if (value.GetError().Fail()) {
      return false;
    }
    vars_.emplace(name, value);
    return true;
  }

  bool CreateContextVariable(std::string name, std::string assignment) {
    return CreateContextVariable("auto", name, false, assignment);
  }

  bool CreateContextVariableArray(std::string type, std::string name,
                                  std::string assignment) {
    return CreateContextVariable(type, name, true, assignment);
  }

  bool Is32Bit() const {
    if (process_.GetAddressByteSize() == 4) {
      return true;
    }
    return false;
  }

protected:
  lldb::SBDebugger debugger_;
  lldb::SBProcess process_;
  lldb::SBFrame frame_;

  // Evaluate with both DIL and LLDB by default.
  bool compare_with_lldb_ = true;

  // Allow the expressions to have side-effects.
  bool allow_side_effects_ = false;

  // Context variables.
  std::unordered_map<std::string, lldb::SBValue> vars_;
};

TEST_F(EvalTest, TestSymbols) {
  EXPECT_GT(frame_.GetModule().GetNumSymbols(), (size_t)0)
      << "No symbols might indicate that the test binary was built incorrectly";
}

#endif

TEST_F(EvalTest, TestArithmetic) {
  EXPECT_THAT(Eval("1 + 2"), IsEqual("3"));
  EXPECT_THAT(Eval("1 + 2*3"), IsEqual("7"));
  EXPECT_THAT(Eval("1 + (2 - 3)"), IsEqual("0"));
  EXPECT_THAT(Eval("1 == 2"), IsEqual("false"));
  EXPECT_THAT(Eval("1 == 1"), IsEqual("true"));

  // Note: Signed overflow is UB.
  EXPECT_THAT(Eval("int_max + 1"), IsOk());
  EXPECT_THAT(Eval("int_min - 1"), IsOk());
  EXPECT_THAT(Eval("2147483647 + 1"), IsOk());
  EXPECT_THAT(Eval("-2147483648 - 1"), IsOk());

  EXPECT_THAT(Eval("uint_max + 1"), IsEqual("0"));
  EXPECT_THAT(Eval("uint_zero - 1"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("4294967295 + 1"), IsEqual("4294967296"));
  EXPECT_THAT(Eval("4294967295U + 1"), IsEqual("0"));

  // Note: Signed overflow is UB.
  EXPECT_THAT(Eval("ll_max + 1"), IsOk());
  EXPECT_THAT(Eval("ll_min - 1"), IsOk());
  EXPECT_THAT(Eval("9223372036854775807 + 1"), IsOk());
  EXPECT_THAT(Eval("-9223372036854775808 - 1"), IsOk());

  EXPECT_THAT(Eval("ull_max + 1"), IsEqual("0"));
  EXPECT_THAT(Eval("ull_zero - 1"), IsEqual("18446744073709551615"));
  EXPECT_THAT(Eval("9223372036854775807 + 1"), IsEqual("-9223372036854775808"));
  EXPECT_THAT(Eval("9223372036854775807LL + 1"),
              IsEqual("-9223372036854775808"));
  EXPECT_THAT(Eval("18446744073709551615ULL + 1"), IsEqual("0"));

  // Integer literal is too large to be represented in a signed integer type,
  // interpreting as unsigned.
  EXPECT_THAT(Eval("-9223372036854775808"), IsEqual("9223372036854775808"));
  EXPECT_THAT(Eval("-9223372036854775808 - 1"), IsEqual("9223372036854775807"));
  EXPECT_THAT(Eval("-9223372036854775808 + 1"), IsEqual("9223372036854775809"));
  EXPECT_THAT(Eval("-9223372036854775808LL / -1"), IsEqual("0"));
  EXPECT_THAT(Eval("-9223372036854775808LL % -1"),
              IsEqual("9223372036854775808"));

  EXPECT_THAT(Eval("-20 / 1U"), IsEqual("4294967276"));
  EXPECT_THAT(Eval("-20LL / 1U"), IsEqual("-20"));
  EXPECT_THAT(Eval("-20LL / 1ULL"), IsEqual("18446744073709551596"));

  // Unary arithmetic.
  EXPECT_THAT(Eval("+0"), IsEqual("0"));
  EXPECT_THAT(Eval("-0"), IsEqual("0"));
  EXPECT_THAT(Eval("+1"), IsEqual("1"));
  EXPECT_THAT(Eval("-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("c"), IsEqual("'\\n'"));
  EXPECT_THAT(Eval("+c"), IsEqual("10"));
  EXPECT_THAT(Eval("-c"), IsEqual("-10"));
  EXPECT_THAT(Eval("uc"), IsEqual("'\\x01'"));
  EXPECT_THAT(Eval("-uc"), IsEqual("-1"));
  EXPECT_THAT(Eval("+p"), IsOk());
  EXPECT_THAT(Eval("-p"),
              IsError("invalid argument type 'int *' to unary expression"));

  // Floating tricks.
  EXPECT_THAT(Eval("+0.0"), IsEqual("0"));
  EXPECT_THAT(Eval("-0.0"), IsEqual("-0"));
  EXPECT_THAT(Eval("0.0 / 0"), IsEqual("NaN"));
  EXPECT_THAT(Eval("0 / 0.0"), IsEqual("NaN"));
  EXPECT_THAT(Eval("1 / +0.0"), IsEqual("+Inf"));
  EXPECT_THAT(Eval("1 / -0.0"), IsEqual("-Inf"));
  EXPECT_THAT(Eval("+0.0 / +0.0  != +0.0 / +0.0"), IsEqual("true"));
  EXPECT_THAT(Eval("-1.f * 0"), IsEqual("-0"));
  EXPECT_THAT(Eval("2. + .5"), IsEqual("2.5"));
  EXPECT_THAT(Eval("1e2"), IsEqual("100"));
  EXPECT_THAT(Eval("1e+2"), IsEqual("100"));
  EXPECT_THAT(Eval(".12e+1"), IsEqual("1.2"));
  EXPECT_THAT(Eval("0x0.123p-1"), IsEqual("0.0355224609375"));

  EXPECT_THAT(Eval("fnan < fnan"), IsEqual("false"));
  EXPECT_THAT(Eval("fnan <= fnan"), IsEqual("false"));
  EXPECT_THAT(Eval("fnan == fnan"), IsEqual("false"));
  EXPECT_THAT(Eval("(unsigned int) fdenorm"), IsEqual("0"));
  EXPECT_THAT(Eval("(unsigned int) (1.0f + fdenorm)"), IsEqual("1"));

  // Invalid remainder.
  EXPECT_THAT(
      Eval("1.1 % 2"),
      IsError("invalid operands to binary expression ('double' and 'int')"));

  // References and typedefs.
  EXPECT_THAT(Eval("r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("r - 1l"), IsEqual("1"));
  EXPECT_THAT(Eval("r * 2u"), IsEqual("4"));
  EXPECT_THAT(Eval("r / 2ull"), IsEqual("1"));
  EXPECT_THAT(Eval("my_r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("my_r - 1"), IsEqual("1"));
  EXPECT_THAT(Eval("my_r * 2"), IsEqual("4"));
  EXPECT_THAT(Eval("my_r / 2"), IsEqual("1"));
  EXPECT_THAT(Eval("r + my_r"), IsEqual("4"));
  EXPECT_THAT(Eval("r - my_r"), IsEqual("0"));
  EXPECT_THAT(Eval("r * my_r"), IsEqual("4"));
  EXPECT_THAT(Eval("r / my_r"), IsEqual("1"));

  // Some promotions and conversions.
  EXPECT_THAT(Eval("(uint8_t)250 + (uint8_t)250"), IsEqual("500"));

  // Makes sure that the expression isn't parsed as two types `r<r>` and `r`.
  EXPECT_THAT(Eval("(r < r > r)"), IsEqual("false"));

  // On Windows sizeof(int) == sizeof(long) == 4.
  if constexpr (sizeof(int) == sizeof(long)) {
    EXPECT_THAT(Eval("(unsigned int)4294967295 + (long)2"), IsEqual("1"));
    EXPECT_THAT(Eval("((unsigned int)1 + (long)1) - 3"), IsEqual("4294967295"));
  } else {
    // On Linux sizeof(int) == 4 and sizeof(long) == 8.
    EXPECT_THAT(Eval("(unsigned int)4294967295 + (long)2"),
                IsEqual("4294967297"));
    EXPECT_THAT(Eval("((unsigned int)1 + (long)1) - 3"), IsEqual("-1"));
  }
}

TEST_F(EvalTest, TestZeroDivision) {
  // Zero division and remainder is UB and LLDB return garbage values.
  // DIL implementation detects division by zero.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("1 / 0"), IsError("Division by zero detected."));
  EXPECT_THAT(Eval("1 / uint_zero"), IsError("Division by zero detected."));
  EXPECT_THAT(Eval("1ll / 0 + 1"), IsError("Division by zero detected."));

  EXPECT_THAT(Eval("1 % 0"), IsError("Division by zero detected."));
  EXPECT_THAT(Eval("1 % uint_zero"), IsError("Division by zero detected."));
  EXPECT_THAT(Eval("1 % uint_zero + 1"), IsError("Division by zero detected."));
}

TEST_F(EvalTest, TestBitwiseOperators) {
  EXPECT_THAT(Eval("~(-1)"), IsEqual("0"));
  EXPECT_THAT(Eval("~~0"), IsEqual("0"));
  EXPECT_THAT(Eval("~0"), IsEqual("-1"));
  EXPECT_THAT(Eval("~1"), IsEqual("-2"));
  EXPECT_THAT(Eval("~0LL"), IsEqual("-1"));
  EXPECT_THAT(Eval("~1LL"), IsEqual("-2"));
  EXPECT_THAT(Eval("~true"), IsEqual("-2"));
  EXPECT_THAT(Eval("~false"), IsEqual("-1"));
  EXPECT_THAT(Eval("~var_true"), IsEqual("-2"));
  EXPECT_THAT(Eval("~var_false"), IsEqual("-1"));
  EXPECT_THAT(Eval("~ull_max"), IsEqual("0"));
  EXPECT_THAT(Eval("~ull_zero"), IsEqual("18446744073709551615"));

  EXPECT_THAT(Eval("~s"),
              IsError("invalid argument type 'S' to unary expression"));
  EXPECT_THAT(
      Eval("~p"),
      IsError("invalid argument type 'const char *' to unary expression"));

  EXPECT_THAT(Eval("(1 << 5)"), IsEqual("32"));
  EXPECT_THAT(Eval("(32 >> 2)"), IsEqual("8"));
  EXPECT_THAT(Eval("(-1 >> 10)"), IsEqual("-1"));
  EXPECT_THAT(Eval("(-100 >> 5)"), IsEqual("-4"));
  EXPECT_THAT(Eval("(-3 << 6)"), IsEqual("-192"));
  EXPECT_THAT(Eval("(2000000000U << 1)"), IsEqual("4000000000"));
  EXPECT_THAT(Eval("(-1 >> 1U)"), IsEqual("-1"));
  EXPECT_THAT(Eval("(char)1 << 16"), IsEqual("65536"));
  EXPECT_THAT(Eval("(signed char)-123 >> 8"), IsEqual("-1"));

  EXPECT_THAT(Eval("0b1011 & 0xFF"), IsEqual("11"));
  EXPECT_THAT(Eval("0b1011 & mask_ff"), XFail(IsEqual("11")));
  EXPECT_THAT(Eval("0b1011 & 0b0111"), IsEqual("3"));
  EXPECT_THAT(Eval("0b1011 | 0b0111"), IsEqual("15"));
  EXPECT_THAT(Eval("-0b1011 | 0xFF"), IsEqual("-1"));
  EXPECT_THAT(Eval("-0b1011 | 0xFFu"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("0b1011 ^ 0b0111"), IsEqual("12"));
  EXPECT_THAT(Eval("~0b1011"), IsEqual("-12"));
}

TEST_F(EvalTest, TestPointerArithmetic) {
  EXPECT_THAT(Eval("p_char1"), IsOk());
  EXPECT_THAT(Eval("p_char1 + 1"), IsOk());
  EXPECT_THAT(Eval("p_char1 + offset"), IsOk());

  EXPECT_THAT(Eval("my_p_char1"), IsOk());
  EXPECT_THAT(Eval("my_p_char1 + 1"), IsOk());
  EXPECT_THAT(Eval("my_p_char1 + offset"), IsOk());

  EXPECT_THAT(Eval("*(p_char1 + 0)"), IsEqual("'h'"));
  EXPECT_THAT(Eval("*(1 + p_char1)"), IsEqual("'e'"));
  EXPECT_THAT(Eval("*(p_char1 + 2)"), IsEqual("'l'"));
  EXPECT_THAT(Eval("*(3 + p_char1)"), IsEqual("'l'"));
  EXPECT_THAT(Eval("*(p_char1 + 4)"), IsEqual("'o'"));
  EXPECT_THAT(Eval("*(p_char1 + offset - 1)"), IsEqual("'o'"));

  EXPECT_THAT(Eval("*p_int0"), IsEqual("0"));
  EXPECT_THAT(Eval("*cp_int5"), IsEqual("5"));
  EXPECT_THAT(Eval("*(&*(cp_int5 + 1) - 1)"), IsEqual("5"));

  EXPECT_THAT(Eval("p_int0 - p_int0"), IsEqual("0"));
  EXPECT_THAT(Eval("cp_int5 - p_int0"), IsEqual("5"));
  EXPECT_THAT(Eval("cp_int5 - td_int_ptr0"), IsEqual("5"));
  EXPECT_THAT(Eval("td_int_ptr0 - cp_int5"), IsEqual("-5"));

  EXPECT_THAT(
      Eval("-p_char1"),
      IsError("invalid argument type 'const char *' to unary expression"));
  EXPECT_THAT(Eval("cp_int5 - p_char1"),
              IsError("'const int *' and 'const char *' are not pointers to "
                      "compatible types"));
  EXPECT_THAT(Eval("p_int0 + cp_int5"),
              IsError("invalid operands to binary expression ('int *' and "
                      "'const int *')"));
  EXPECT_THAT(Eval("p_int0 > p_char1"),
              IsError("comparison of distinct pointer types ('int *' and "
                      "'const char *')"));

  EXPECT_THAT(Eval("cp_int5 > td_int_ptr0"), IsEqual("true"));
  EXPECT_THAT(Eval("cp_int5 < td_int_ptr0"), IsEqual("false"));
  EXPECT_THAT(Eval("cp_int5 != td_int_ptr0"), IsEqual("true"));
  EXPECT_THAT(Eval("cp_int5 == td_int_ptr0 + offset"), IsEqual("true"));

  EXPECT_THAT(Eval("p_void + 1"), IsError("arithmetic on a pointer to void"));
  EXPECT_THAT(Eval("p_void - 1"), IsError("arithmetic on a pointer to void"));
  EXPECT_THAT(Eval("p_void - p_char1"),
              IsError("'void *' and 'const char *' are not pointers to "
                      "compatible types"));
  EXPECT_THAT(Eval("p_void - p_void"),
              IsError("arithmetic on pointers to void"));

  EXPECT_THAT(Eval("pp_void0 - p_char1"),
              IsError("'void **' and 'const char *' are not pointers to "
                      "compatible types"));
  EXPECT_THAT(Eval("pp_void0 == p_char1"),
              IsError("comparison of distinct pointer types ('void **' and "
                      "'const char *')"));

  EXPECT_THAT(Eval("+array"), IsOk());
  EXPECT_THAT(Eval("+array_ref"), IsOk());
  EXPECT_THAT(Eval("-array"),
              IsError("invalid argument type 'int *' to unary expression\n"
                      "-array\n"
                      "^"));

  EXPECT_THAT(Eval("array + 1"), IsOk());
  EXPECT_THAT(Eval("1 + array"), IsOk());
  EXPECT_THAT(Eval("array_ref + 1"), IsOk());
  EXPECT_THAT(Eval("1 + array_ref"), IsOk());

  EXPECT_THAT(Eval("array - 1"), IsOk());
  EXPECT_THAT(Eval("array_ref - 1"), IsOk());
  EXPECT_THAT(
      Eval("1 - array"),
      IsError("invalid operands to binary expression ('int' and 'int[10]')\n"
              "1 - array\n"
              "  ^"));

  EXPECT_THAT(Eval("array - array"), IsEqual("0"));
  EXPECT_THAT(Eval("array - array_ref"), IsEqual("0"));
  EXPECT_THAT(Eval("array_ref - array_ref"), IsEqual("0"));
  EXPECT_THAT(
      Eval("array + array"),
      IsError(
          "invalid operands to binary expression ('int[10]' and 'int[10]')\n"
          "array + array\n"
          "      ^"));
}

TEST_F(EvalTest, PointerPointerArithmeticFloat) {
  EXPECT_THAT(
      Eval("(int*)0 + 1.1"),
      IsError("invalid operands to binary expression ('int *' and 'double')"));
  EXPECT_THAT(
      Eval("1.1 + (int*)0"),
      IsError("invalid operands to binary expression ('double' and 'int *')"));
  EXPECT_THAT(
      Eval("(int*)0 - 1.1"),
      IsError("invalid operands to binary expression ('int *' and 'double')"));
}

TEST_F(EvalTest, PointerPointerComparison) {
  EXPECT_THAT(Eval("p_void == p_void"), IsEqual("true"));
  EXPECT_THAT(Eval("p_void == p_char1"), IsEqual("true"));
  EXPECT_THAT(Eval("p_void != p_char1"), IsEqual("false"));
  EXPECT_THAT(Eval("p_void > p_char1"), IsEqual("false"));
  EXPECT_THAT(Eval("p_void >= p_char1"), IsEqual("true"));
  EXPECT_THAT(Eval("p_void < (p_char1 + 1)"), IsEqual("true"));
  EXPECT_THAT(Eval("pp_void0 + 1 == pp_void1"), IsEqual("true"));

  EXPECT_THAT(Eval("(void*)1 == (void*)1"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)1 != (void*)1"), IsEqual("false"));
  EXPECT_THAT(Eval("(void*)2 > (void*)1"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)2 < (void*)1"), IsEqual("false"));

  EXPECT_THAT(Eval("(void*)1 == (char*)1"), IsEqual("true"));
  EXPECT_THAT(Eval("(char*)1 != (void*)1"), IsEqual("false"));
  EXPECT_THAT(Eval("(void*)2 > (char*)1"), IsEqual("true"));
  EXPECT_THAT(Eval("(char*)2 < (void*)1"), IsEqual("false"));
}

TEST_F(EvalTest, PointerIntegerComparison) {
  EXPECT_THAT(Eval("(void*)0 == 0"), IsEqual("true"));
  EXPECT_THAT(Eval("0 != (void*)0"), IsEqual("false"));

  EXPECT_THAT(Eval("(void*)0 == nullptr"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)0 != nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr == (void*)1"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr != (void*)1"), IsEqual("true"));

  EXPECT_THAT(Eval("nullptr == nullptr"), IsEqual("true"));
  EXPECT_THAT(Eval("nullptr != nullptr"), IsEqual("false"));

  EXPECT_THAT(Eval("nullptr == 0"), IsEqual("true"));
  EXPECT_THAT(Eval("0 != nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr == 0U"), IsEqual("true"));
  EXPECT_THAT(Eval("0L != nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr == 0UL"), IsEqual("true"));
  EXPECT_THAT(Eval("0ULL != nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr == 0x0"), IsEqual("true"));
  EXPECT_THAT(Eval("0b0 != nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("nullptr == 00"), IsEqual("true"));
  EXPECT_THAT(Eval("0x0LLU != nullptr"), IsEqual("false"));

  EXPECT_THAT(Eval("0 == std_nullptr_t"), IsEqual("true"));
  EXPECT_THAT(Eval("std_nullptr_t != 0"), IsEqual("false"));

  EXPECT_THAT(Eval("(void*)0 > nullptr"),
              IsError("invalid operands to binary expression ('void *' and "
                      "'std::nullptr_t')"));

  EXPECT_THAT(Eval("nullptr > 0"),
              IsError("invalid operands to binary expression ('std::nullptr_t' "
                      "and 'int')"));

  EXPECT_THAT(Eval("1 == nullptr"),
              IsError("invalid operands to binary expression ('int' and "
                      "'std::nullptr_t')"));

  EXPECT_THAT(Eval("nullptr == (int)0"),
              IsError("invalid operands to binary expression ('std::nullptr_t' "
                      "and 'int')"));

  EXPECT_THAT(Eval("false == nullptr"),
              IsError("invalid operands to binary expression ('bool' and "
                      "'std::nullptr_t')"));

  EXPECT_THAT(Eval("nullptr == (true ? 0 : 0)"),
              IsError("invalid operands to binary expression ('std::nullptr_t' "
                      "and 'int')"));

  EXPECT_THAT(
      Eval("nullptr > nullptr"),
      IsError("invalid operands to binary expression ('std::nullptr_t' and "
              "'std::nullptr_t')"));

  // These are not allowed by C++, but we support it as an extension.
  EXPECT_THAT(Eval("(void*)1 == 1"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)1 == 0"), IsEqual("false"));
  EXPECT_THAT(Eval("(void*)1 > 0"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)1 < 0"), IsEqual("false"));
  EXPECT_THAT(Eval("1 > (void*)0"), IsEqual("true"));
  EXPECT_THAT(Eval("2 < (void*)3"), IsEqual("true"));

  // Integer is converted to uintptr_t, so negative numbers because large
  // positive numbers.
  EXPECT_THAT(Eval("(void*)0xffffffffffffffff == -1"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)-1 == -1"), IsEqual("true"));
  EXPECT_THAT(Eval("(void*)1 > -1"), IsEqual("false"));
}

TEST_F(EvalTest, TestPointerDereference) {
  EXPECT_THAT(Eval("*p_int0"), IsEqual("0"));
  EXPECT_THAT(Eval("*p_int0 + 1"), IsEqual("1"));
  EXPECT_THAT(Eval("*cp_int5"), IsEqual("5"));
  EXPECT_THAT(Eval("*cp_int5 - 1"), IsEqual("4"));

  EXPECT_THAT(Eval("&*p_null"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("&p_null[4]"),
              IsEqual(Is32Bit() ? "0x00000010" : "0x0000000000000010"));
  EXPECT_THAT(Eval("&*(int*)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("&((int*)0)[1]"),
              IsEqual(Is32Bit() ? "0x00000004" : "0x0000000000000004"));

  EXPECT_THAT(Eval("&p_void[0]"),
              IsError("subscript of pointer to incomplete type 'void'"));
  EXPECT_THAT(Eval("&*p_void"),
              XFail(IsError("indirection not permitted on operand of type"
                            " 'void *'")));
  EXPECT_THAT(Eval("&pp_void0[2]"), IsOk());

  EXPECT_THAT(Eval("**pp_int0"), IsEqual("0"));
  EXPECT_THAT(Eval("**pp_int0 + 1"), IsEqual("1"));
  EXPECT_THAT(Eval("&**pp_int0"), IsOk());
  EXPECT_THAT(Eval("&**pp_int0 + 1"), IsOk());

  EXPECT_THAT(Eval("&(true ? *p_null : *p_null)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  EXPECT_THAT(Eval("&(false ? *p_null : *p_null)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("&*(true ? p_null : nullptr)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
}

TEST_F(EvalTest, TestLogicalOperators) {
  EXPECT_THAT(Eval("1 > 2"), IsEqual("false"));
  EXPECT_THAT(Eval("1 == 1"), IsEqual("true"));
  EXPECT_THAT(Eval("1 > 0.1"), IsEqual("true"));
  EXPECT_THAT(Eval("1 && 2"), IsEqual("true"));
  EXPECT_THAT(Eval("0 && 1"), IsEqual("false"));
  EXPECT_THAT(Eval("0 || 1"), IsEqual("true"));
  EXPECT_THAT(Eval("0 || 0"), IsEqual("false"));

  EXPECT_THAT(Eval("!1"), IsEqual("false"));
  EXPECT_THAT(Eval("!!1"), IsEqual("true"));

  EXPECT_THAT(Eval("!trueVar"), IsEqual("false"));
  EXPECT_THAT(Eval("!!trueVar"), IsEqual("true"));
  EXPECT_THAT(Eval("!falseVar"), IsEqual("true"));
  EXPECT_THAT(Eval("!!falseVar"), IsEqual("false"));

  EXPECT_THAT(Eval("trueVar && true"), IsEqual("true"));
  EXPECT_THAT(Eval("trueVar && (2 > 1)"), IsEqual("true"));
  EXPECT_THAT(Eval("trueVar && (2 < 1)"), IsEqual("false"));

  EXPECT_THAT(Eval("falseVar || true"), IsEqual("true"));
  EXPECT_THAT(Eval("falseVar && true"), IsEqual("false"));
  EXPECT_THAT(Eval("falseVar || (2 > 1)"), IsEqual("true"));
  EXPECT_THAT(Eval("falseVar || (2 < 1)"), IsEqual("false"));

  EXPECT_THAT(Eval("true || __doesnt_exist"),
              IsError("use of undeclared identifier '__doesnt_exist'"));
  EXPECT_THAT(Eval("false && __doesnt_exist"),
              IsError("use of undeclared identifier '__doesnt_exist'"));

  EXPECT_THAT(Eval("!p_ptr"), IsEqual("false"));
  EXPECT_THAT(Eval("!!p_ptr"), IsEqual("true"));
  EXPECT_THAT(Eval("p_ptr && true"), IsEqual("true"));
  EXPECT_THAT(Eval("p_ptr && false"), IsEqual("false"));
  EXPECT_THAT(Eval("!p_nullptr"), IsEqual("true"));
  EXPECT_THAT(Eval("!!p_nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("p_nullptr || true"), IsEqual("true"));
  EXPECT_THAT(Eval("p_nullptr || false"), IsEqual("false"));

  EXPECT_THAT(Eval("!array"), IsEqual("false"));
  EXPECT_THAT(Eval("!!array"), IsEqual("true"));
  EXPECT_THAT(Eval("array || true"), IsEqual("true"));
  EXPECT_THAT(Eval("false || array"), IsEqual("true"));
  EXPECT_THAT(Eval("array && true"), IsEqual("true"));
  EXPECT_THAT(Eval("array && false"), IsEqual("false"));

  EXPECT_THAT(Eval("false || !s"),
              IsError("invalid argument type 'S' to unary expression\n"
                      "false || !s\n"
                      "         ^"));
  EXPECT_THAT(
      Eval("s || false"),
      IsError("value of type 'S' is not contextually convertible to 'bool'\n"
              "s || false\n"
              "^"));
  EXPECT_THAT(
      Eval("true || s"),
      IsError("value of type 'S' is not contextually convertible to 'bool'\n"
              "true || s\n"
              "        ^"));
  EXPECT_THAT(
      Eval("s ? 1 : 2"),
      IsError("value of type 'S' is not contextually convertible to 'bool'"));
}

TEST_F(EvalTest, TestLocalVariables) {
  EXPECT_THAT(Eval("a"), IsEqual("1"));
  EXPECT_THAT(Eval("b"), IsEqual("2"));
  EXPECT_THAT(Eval("a + b"), IsEqual("3"));

  EXPECT_THAT(Eval("c + 1"), IsEqual("-2"));
  EXPECT_THAT(Eval("s + 1"), IsEqual("5"));
  EXPECT_THAT(Eval("c + s"), IsEqual("1"));

  EXPECT_THAT(Eval("__test_non_variable + 1"),
              IsError("use of undeclared identifier '__test_non_variable'"));
}

TEST_F(EvalTest, TestMemberOf) {
  EXPECT_THAT(Eval("s.x"), IsEqual("1"));
  EXPECT_THAT(Eval("s.r"), IsEqual("2"));
  EXPECT_THAT(Eval("s.r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("sr.x"), IsEqual("1"));
  EXPECT_THAT(Eval("sr.r"), IsEqual("2"));
  EXPECT_THAT(Eval("sr.r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("sp->x"), IsEqual("1"));
  EXPECT_THAT(Eval("sp->r"), IsEqual("2"));
  EXPECT_THAT(Eval("sp->r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("sarr->x"), IsEqual("5"));
  EXPECT_THAT(Eval("sarr->r"), IsEqual("2"));
  EXPECT_THAT(Eval("sarr->r + 1"), IsEqual("3"));
  EXPECT_THAT(Eval("(sarr + 1)->x"), IsEqual("1"));

  EXPECT_THAT(
      Eval("sp->4"),
      IsError(
          "<expr:1:5>: expected 'identifier', got: <'4' (numeric_constant)>\n"
          "sp->4\n"
          "    ^"));
  EXPECT_THAT(Eval("sp->foo"), IsError("no member named 'foo' in 'Sx'"));
  EXPECT_THAT(
      Eval("sp->r / (void*)0"),
      IsError("invalid operands to binary expression ('int' and 'void *')"));

  EXPECT_THAT(Eval("sp.x"), IsError("member reference type 'Sx *' is a "
                                    "pointer; did you mean to use '->'"));
  EXPECT_THAT(
      Eval("sarr.x"),
      IsError(
          "member reference base type 'Sx[2]' is not a structure or union"));

  // Test for record typedefs.
  EXPECT_THAT(Eval("sa.x"), IsEqual("3"));
  EXPECT_THAT(Eval("sa.y"), IsEqual("'\\x04'"));

  // TODO(werat): Implement address-of-member-or combination.
  // EXPECT_THAT(Eval("&((Sx*)0)->x"), IsEqual("0x0000000000000000"));
  // EXPECT_THAT(Eval("&((Sx*)0)->y"), IsEqual("0x0000000000000010"));
  // EXPECT_THAT(Eval("&(*(Sx*)0).x"), IsEqual("0x0000000000000000"));
  // EXPECT_THAT(Eval("&(*(Sx*)0).y"), IsEqual("0x0000000000000010"));
}

TEST_F(EvalTest, TestMemberOfInheritance) {
  EXPECT_THAT(Eval("a.a_"), IsEqual("1"));
  EXPECT_THAT(Eval("b.b_"), IsEqual("2"));
  EXPECT_THAT(Eval("c.a_"), IsEqual("1"));
  EXPECT_THAT(Eval("c.b_"), IsEqual("2"));
  EXPECT_THAT(Eval("c.c_"), IsEqual("3"));
  EXPECT_THAT(Eval("d.a_"), IsEqual("1"));
  EXPECT_THAT(Eval("d.b_"), IsEqual("2"));
  EXPECT_THAT(Eval("d.c_"), IsEqual("3"));
  EXPECT_THAT(Eval("d.d_"), IsEqual("4"));
  EXPECT_THAT(Eval("d.fa_.a_"), IsEqual("5"));

  EXPECT_THAT(Eval("bat.weight_"), IsEqual("10"));

  EXPECT_THAT(Eval("plugin.x"), IsEqual("1"));
  EXPECT_THAT(Eval("plugin.y"), IsEqual("2"));

  EXPECT_THAT(Eval("engine.x"), IsEqual("1"));
  EXPECT_THAT(Eval("engine.y"), IsEqual("2"));
  EXPECT_THAT(Eval("engine.z"), IsEqual("3"));

  EXPECT_THAT(Eval("parent_base->x"), IsEqual("1"));
  EXPECT_THAT(Eval("parent_base->y"), IsEqual("2"));
  EXPECT_THAT(Eval("parent->x"), IsEqual("1"));
  EXPECT_THAT(Eval("parent->y"), IsEqual("2"));
  EXPECT_THAT(Eval("parent->z"), IsEqual("3"));
}

TEST_F(EvalTest, TestMemberOfAnonymousMember) {
  EXPECT_THAT(Eval("a.x"), IsEqual("1"));
  EXPECT_THAT(Eval("a.y"), IsEqual("2"));

  EXPECT_THAT(Eval("b.x"), IsError("no member named 'x' in 'B'"));
  EXPECT_THAT(Eval("b.y"), IsError("no member named 'y' in 'B'"));
  EXPECT_THAT(Eval("b.z"), IsEqual("3"));
  EXPECT_THAT(Eval("b.w"), IsEqual("4"));
  EXPECT_THAT(Eval("b.a.x"), IsEqual("1"));
  EXPECT_THAT(Eval("b.a.y"), IsEqual("2"));

  EXPECT_THAT(Eval("c.x"), IsEqual("5"));
  EXPECT_THAT(Eval("c.y"), IsEqual("6"));

  EXPECT_THAT(Eval("d.x"), IsEqual("7"));
  EXPECT_THAT(Eval("d.y"), IsEqual("8"));
  EXPECT_THAT(Eval("d.z"), IsEqual("9"));
  EXPECT_THAT(Eval("d.w"), IsEqual("10"));

  EXPECT_THAT(Eval("e.x"), IsError("no member named 'x' in 'E'"));
  EXPECT_THAT(Eval("f.x"), IsError("no member named 'x' in 'F'"));
  EXPECT_THAT(Eval("f.named_field.x"), IsEqual("12"));

  EXPECT_THAT(Eval("unnamed_derived.x"), IsEqual("1"));
  EXPECT_THAT(Eval("unnamed_derived.y"), IsEqual("2"));
  EXPECT_THAT(Eval("unnamed_derived.z"), IsEqual("13"));

  EXPECT_THAT(Eval("derb.x"), IsError("no member named 'x' in 'DerivedB'"));
  EXPECT_THAT(Eval("derb.y"), IsError("no member named 'y' in 'DerivedB'"));
  EXPECT_THAT(Eval("derb.z"), IsEqual("3"));
  EXPECT_THAT(Eval("derb.w"), IsEqual("14"));
  EXPECT_THAT(Eval("derb.k"), IsEqual("15"));
  EXPECT_THAT(Eval("derb.a.x"), IsEqual("1"));
  EXPECT_THAT(Eval("derb.a.y"), IsEqual("2"));
}

TEST_F(EvalTest, TestGlobalVariableLookup) {
  EXPECT_THAT(Eval("globalVar"), IsEqual("-559038737")); // 0xDEADBEEF
  EXPECT_THAT(Eval("globalPtr"), IsOk());
  EXPECT_THAT(Eval("globalRef"), IsEqual("-559038737"));
  EXPECT_THAT(Eval("::globalPtr"), IsOk());
  EXPECT_THAT(Eval("::globalRef"), IsEqual("-559038737"));

  EXPECT_THAT(Eval("externGlobalVar"),
              XFail(IsEqual("12648430"))); // 0x00C0FFEE
  EXPECT_THAT(Eval("::externGlobalVar"), XFail(IsEqual("12648430")));

  EXPECT_THAT(Eval("ns::globalVar"), IsEqual("13"));
  EXPECT_THAT(Eval("ns::globalPtr"), IsOk());
  EXPECT_THAT(Eval("ns::globalRef"), IsEqual("13"));
  EXPECT_THAT(Eval("::ns::globalVar"), IsEqual("13"));
  EXPECT_THAT(Eval("::ns::globalPtr"), IsOk());
}

TEST_F(EvalTest, TestInstanceVariables) {
  EXPECT_THAT(Eval("this->field_"), IsEqual("1"));
  EXPECT_THAT(Eval("this.field_"),
              IsError("member reference type 'TestMethods *' is a pointer; did "
                      "you mean to use '->'?"));

  EXPECT_THAT(Eval("c.field_"), IsEqual("-1"));
  EXPECT_THAT(Eval("c_ref.field_"), IsEqual("-1"));
  EXPECT_THAT(Eval("c_ptr->field_"), IsEqual("-1"));
  EXPECT_THAT(Eval("c->field_"), IsError("member reference type 'C' is not a "
                                         "pointer; did you mean to use '.'?"));
}

TEST_F(EvalTest, TestIndirection) {
  EXPECT_THAT(Eval("*p"), IsEqual("1"));
  EXPECT_THAT(Eval("p"), IsOk());
  EXPECT_THAT(Eval("*my_p"), IsEqual("1"));
  EXPECT_THAT(Eval("my_p"), IsOk());
  EXPECT_THAT(Eval("*my_pr"), IsEqual("1"));
  EXPECT_THAT(Eval("my_pr"), IsOk());

  EXPECT_THAT(Eval("*1"),
              IsError("indirection requires pointer operand ('int' invalid)"));
  EXPECT_THAT(Eval("*val"),
              IsError("indirection requires pointer operand ('int' invalid)"));
}

TEST_F(EvalTest, TestAddressOf) {
  EXPECT_THAT(Eval("&x"), IsOk());
  EXPECT_THAT(Eval("r"), IsOk());
  EXPECT_THAT(Eval("&r"), IsOk());
  EXPECT_THAT(Eval("pr"), IsOk());
  EXPECT_THAT(Eval("&pr"), IsOk());
  EXPECT_THAT(Eval("my_pr"), IsOk());
  EXPECT_THAT(Eval("&my_pr"), IsOk());

  EXPECT_THAT(Eval("&x == &r"), IsEqual("true"));
  EXPECT_THAT(Eval("&x != &r"), IsEqual("false"));

  EXPECT_THAT(Eval("&p == &pr"), IsEqual("true"));
  EXPECT_THAT(Eval("&p != &pr"), IsEqual("false"));
  EXPECT_THAT(Eval("&p == &my_pr"), IsEqual("true"));
  EXPECT_THAT(Eval("&p != &my_pr"), IsEqual("false"));

  EXPECT_THAT(Eval("&globalVar"), IsOk());
  EXPECT_THAT(Eval("&externGlobalVar"), XFail(IsOk()));
  EXPECT_THAT(Eval("&s_str"), IsOk());
  EXPECT_THAT(Eval("&param"), IsOk());

  EXPECT_THAT(Eval("&1"),
              IsError("cannot take the address of an rvalue of type 'int'"));
  EXPECT_THAT(Eval("&0.1"),
              IsError("cannot take the address of an rvalue of type 'double'"));

  EXPECT_THAT(
      Eval("&this"),
      IsError("cannot take the address of an rvalue of type 'TestMethods *'"));
  EXPECT_THAT(
      Eval("&(&s_str)"),
      IsError("cannot take the address of an rvalue of type 'const char **'"));

  EXPECT_THAT(Eval("&(true ? x : x)"), IsOk());
  EXPECT_THAT(Eval("&(true ? 1 : 1)"),
              IsError("cannot take the address of an rvalue of type 'int'"));

  EXPECT_THAT(Eval("&(true ? c : c)"), IsOk());
  EXPECT_THAT(Eval("&(true ? c : (char)1)"),
              IsError("cannot take the address of an rvalue of type 'char'"));
  EXPECT_THAT(Eval("&(true ? c : 1)"),
              IsError("cannot take the address of an rvalue of type 'int'"));
}

TEST_F(EvalTest, TestSubscript) {
  // const char*
  EXPECT_THAT(Eval("char_ptr[0]"), IsEqual("'l'"));
  EXPECT_THAT(Eval("1[char_ptr]"), IsEqual("'o'"));

  // const char[]
  EXPECT_THAT(Eval("char_arr[0]"), IsEqual("'i'"));
  EXPECT_THAT(Eval("1[char_arr]"), IsEqual("'p'"));

  // Boolean types are integral too!
  EXPECT_THAT(Eval("int_arr[false]"), IsEqual("1"));
  EXPECT_THAT(Eval("true[int_arr]"), IsEqual("2"));

  // As well as unscoped enums.
  EXPECT_THAT(Eval("int_arr[enum_one]"), IsEqual("2"));
  EXPECT_THAT(Eval("enum_one[int_arr]"), IsEqual("2"));

  // But floats are not.
  EXPECT_THAT(Eval("int_arr[1.0]"),
              IsError("array subscript is not an integer"));

  // Base should be a "pointer to T" and index should be of an integral type.
  EXPECT_THAT(Eval("char_arr[char_ptr]"),
              IsError("array subscript is not an integer"));
  EXPECT_THAT(Eval("1[2]"),
              IsError("subscripted value is not an array or pointer"));

  // Test when base and index are references.
  EXPECT_THAT(Eval("c_arr[0].field_"), IsEqual("0"));
  EXPECT_THAT(Eval("c_arr[idx_1_ref].field_"), IsEqual("1"));
  EXPECT_THAT(Eval("c_arr[enum_ref].field_"), IsEqual("1"));
  EXPECT_THAT(Eval("c_arr_ref[0].field_"), IsEqual("0"));
  EXPECT_THAT(Eval("c_arr_ref[idx_1_ref].field_"), IsEqual("1"));
  EXPECT_THAT(Eval("c_arr_ref[enum_ref].field_"), IsEqual("1"));

  // Test when base and index are typedefs.
  bool compare_types = true;
#if LLVM_VERSION_MAJOR < 12
  // Older LLVM versions return canonical types when accessing array elements.
  compare_types = false;
#endif
  EXPECT_THAT(Eval("td_int_arr[0]"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("td_int_arr[td_int_idx_1]"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("td_int_arr[td_td_int_idx_2]"), IsEqual("3", compare_types));
  EXPECT_THAT(Eval("td_int_ptr[0]"), IsEqual("1"));
  EXPECT_THAT(Eval("td_int_ptr[td_int_idx_1]"), IsEqual("2"));
  EXPECT_THAT(Eval("td_int_ptr[td_td_int_idx_2]"), IsEqual("3"));
  // Both typedefs and refs!
  EXPECT_THAT(Eval("td_int_arr_ref[td_int_idx_1_ref]"),
              IsEqual("2", compare_types));

  // Test for index out of bounds.
  EXPECT_THAT(Eval("int_arr[42]"), IsOk());
  EXPECT_THAT(Eval("int_arr[100]"), IsOk());

  // Test for negative index.
  EXPECT_THAT(Eval("int_arr[-1]"), IsOk());
  EXPECT_THAT(Eval("int_arr[-42]"), IsOk());

  // Test for "max unsigned char".
  EXPECT_THAT(Eval("uint8_arr[uchar_idx]"), IsEqual("'\\xab'", compare_types));

  // Test address-of of the subscripted value.
  EXPECT_THAT(Eval("(&c_arr[1])->field_"), XFail(IsEqual("1")));
}

TEST_F(EvalTest, TestCStyleCastBuiltins) {
  EXPECT_THAT(Eval("(int)1"), IsOk());
  EXPECT_THAT(Eval("(long long)1"), IsOk());
  EXPECT_THAT(Eval("(unsigned long)1"), IsOk());
  EXPECT_THAT(Eval("(long const const)1"), IsOk());
  EXPECT_THAT(Eval("(long const long)1"), IsOk());

  EXPECT_THAT(Eval("(char*)1"), IsOk());
  EXPECT_THAT(Eval("(long long**)1"), IsOk());
  EXPECT_THAT(Eval("(const long const long const* const const)1"), IsOk());

  EXPECT_THAT(
      Eval("(long&*)1"),
      IsError(
          "'type name' declared as a pointer to a reference of type 'long &'\n"
          "(long&*)1\n"
          "      ^"));

  EXPECT_THAT(Eval("(long& &)1"),
              IsError("type name declared as a reference to a reference\n"
                      "(long& &)1\n"
                      "       ^"));

  EXPECT_THAT(
      Eval("(long 1)1"),
      IsError("<expr:1:7>: expected 'r_paren', got: <'1' (numeric_constant)>\n"
              "(long 1)1\n"
              "      ^"));
}

TEST_F(EvalTest, TestCStyleCastBasicType) {
  // Test with integer literals.
  EXPECT_THAT(Eval("(char)1"), IsEqual("'\\x01'"));
  EXPECT_THAT(Eval("(unsigned char)-1"), IsEqual("'\\xff'"));
  EXPECT_THAT(Eval("(short)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(unsigned short)-1"), IsEqual("65535"));
  EXPECT_THAT(Eval("(long long)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(unsigned long long)-1"), IsEqual("18446744073709551615"));
  EXPECT_THAT(Eval("(short)65534"), IsEqual("-2"));
  EXPECT_THAT(Eval("(unsigned short)100000"), IsEqual("34464"));
  EXPECT_THAT(Eval("(int)false"), IsEqual("0"));
  EXPECT_THAT(Eval("(int)true"), IsEqual("1"));
  EXPECT_THAT(Eval("(float)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(float)1.1"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(float)1.1f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(float)-1.1"), IsEqual("-1.10000002"));
  EXPECT_THAT(Eval("(float)-1.1f"), IsEqual("-1.10000002"));
  EXPECT_THAT(Eval("(float)false"), IsEqual("0"));
  EXPECT_THAT(Eval("(float)true"), IsEqual("1"));
  EXPECT_THAT(Eval("(double)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(double)1.1"), IsEqual("1.1000000000000001"));
  EXPECT_THAT(Eval("(double)1.1f"), IsEqual("1.1000000238418579"));
  EXPECT_THAT(Eval("(double)-1.1"), IsEqual("-1.1000000000000001"));
  EXPECT_THAT(Eval("(double)-1.1f"), IsEqual("-1.1000000238418579"));
  EXPECT_THAT(Eval("(double)false"), IsEqual("0"));
  EXPECT_THAT(Eval("(double)true"), IsEqual("1"));
  EXPECT_THAT(Eval("(int)1.1"), IsEqual("1"));
  EXPECT_THAT(Eval("(int)1.1f"), IsEqual("1"));
  EXPECT_THAT(Eval("(int)-1.1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(long)1.1"), IsEqual("1"));
  EXPECT_THAT(Eval("(long)-1.1f"), IsEqual("-1"));
  EXPECT_THAT(Eval("(bool)0"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)0.0"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)0.0f"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)3"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)-3"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)-3.4"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)-0.1"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)-0.1f"), IsEqual("true"));

  EXPECT_THAT(Eval("&(int)1"),
              IsError("cannot take the address of an rvalue of type 'int'"));

  // Test with variables.
  EXPECT_THAT(Eval("(char)a"), IsEqual("'\\x01'"));
  EXPECT_THAT(Eval("(unsigned char)na"), IsEqual("'\\xff'"));
  EXPECT_THAT(Eval("(short)na"), IsEqual("-1"));
  EXPECT_THAT(Eval("(unsigned short)-a"), IsEqual("65535"));
  EXPECT_THAT(Eval("(long long)a"), IsEqual("1"));
  EXPECT_THAT(Eval("(unsigned long long)-1"), IsEqual("18446744073709551615"));
  EXPECT_THAT(Eval("(float)a"), IsEqual("1"));
  EXPECT_THAT(Eval("(float)f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(double)f"), IsEqual("1.1000000238418579"));
  EXPECT_THAT(Eval("(int)f"), IsEqual("1"));
  EXPECT_THAT(Eval("(long)f"), IsEqual("1"));
  EXPECT_THAT(Eval("(bool)finf"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)fnan"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)fsnan"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)fmax"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)fdenorm"), IsEqual("true"));

  EXPECT_THAT(
      Eval("(int)ns_foo_"),
      IsError(
          "cannot convert 'ns::Foo' to 'int' without a conversion operator"));

  // Test with typedefs and namespaces.
  EXPECT_THAT(Eval("(myint)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(myint)1LL"), IsEqual("1"));
  EXPECT_THAT(Eval("(ns::myint)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(::ns::myint)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(::ns::myint)myint_"), IsEqual("1"));

  EXPECT_THAT(Eval("(int)myint_"), IsEqual("1"));
  EXPECT_THAT(Eval("(int)ns_myint_"), IsEqual("2"));
  EXPECT_THAT(Eval("(long long)myint_"), IsEqual("1"));
  EXPECT_THAT(Eval("(long long)ns_myint_"), IsEqual("2"));
  EXPECT_THAT(Eval("(::ns::myint)myint_"), IsEqual("1"));

  EXPECT_THAT(Eval("(ns::inner::mydouble)1"), IsEqual("1"));
  EXPECT_THAT(Eval("(::ns::inner::mydouble)1.2"), IsEqual("1.2"));
  EXPECT_THAT(Eval("(ns::inner::mydouble)myint_"), IsEqual("1"));
  EXPECT_THAT(Eval("(::ns::inner::mydouble)ns_inner_mydouble_"),
              IsEqual("1.2"));
  EXPECT_THAT(Eval("(myint)ns_inner_mydouble_"), IsEqual("1"));

  // Test with pointers and arrays.
  EXPECT_THAT(Eval("(long long)ap"), IsOk());
  EXPECT_THAT(Eval("(unsigned long long)vp"), IsOk());
  EXPECT_THAT(Eval("(long long)arr"), IsOk());
  EXPECT_THAT(Eval("(bool)ap"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)(int*)0x00000000"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)nullptr"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)arr"), IsEqual("true"));
  EXPECT_THAT(
      Eval("(char)ap"),
      IsError("cast from pointer to smaller type 'char' loses information"));
  if (Is32Bit()) {
    EXPECT_THAT(Eval("(int)arr"), IsOk());
  } else {
    EXPECT_THAT(
        Eval("(int)arr"),
        IsError("cast from pointer to smaller type 'int' loses information"));
  }

#ifdef _WIN32
  EXPECT_THAT(
      Eval("(long)ap"),
      IsError("cast from pointer to smaller type 'long' loses information"));
#endif

  EXPECT_THAT(Eval("(float)ap"),
              IsError("C-style cast from 'int *' to 'float' is not allowed"));
  EXPECT_THAT(Eval("(float)arr"),
              IsError("C-style cast from 'int *' to 'float' is not allowed"));
}

TEST_F(EvalTest, TestCStyleCastPointer) {
  EXPECT_THAT(Eval("(void*)&a"), IsOk());
  EXPECT_THAT(Eval("(void*)ap"), IsOk());
  EXPECT_THAT(Eval("(long long*)vp"), IsOk());
  EXPECT_THAT(Eval("(short int*)vp"), IsOk());
  EXPECT_THAT(Eval("(unsigned long long*)vp"), IsOk());
  EXPECT_THAT(Eval("(unsigned short int*)vp"), IsOk());

  EXPECT_THAT(Eval("(void*)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("(void*)1"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));
  EXPECT_THAT(Eval("(void*)a"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));
  EXPECT_THAT(Eval("(void*)na"),
              IsEqual(Is32Bit() ? "0xffffffff" : "0xffffffffffffffff"));
  EXPECT_THAT(Eval("(int*&)ap"), IsOk());

  EXPECT_THAT(
      Eval("(char*) 1.0"),
      IsError("cannot cast from type 'double' to pointer type 'char *'"));

  EXPECT_THAT(Eval("*(const int* const)ap"), IsEqual("1"));
  EXPECT_THAT(Eval("*(volatile int* const)ap"), IsEqual("1"));
  EXPECT_THAT(Eval("*(const int* const)vp"), IsEqual("1"));
  EXPECT_THAT(Eval("*(const int* const volatile const)vp"), IsEqual("1"));
  EXPECT_THAT(Eval("*(int*)(void*)ap"), IsEqual("1"));
  EXPECT_THAT(Eval("*(int*)(const void* const volatile)ap"), IsEqual("1"));

  EXPECT_THAT(Eval("(ns::Foo*)ns_inner_foo_ptr_"), IsOk());
  EXPECT_THAT(Eval("(ns::inner::Foo*)ns_foo_ptr_"), IsOk());

  EXPECT_THAT(Eval("(int& &)ap"),
              IsError("type name declared as a reference to a reference"));
  EXPECT_THAT(Eval("(int&*)ap"), IsError("'type name' declared as a pointer "
                                         "to a reference of type 'int &'"));

  GTEST_SKIP() << "Segfault when retrieving result value in the matcher";
  EXPECT_THAT(Eval("(nullptr_t)nullptr"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("(nullptr_t)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  EXPECT_THAT(Eval("(nullptr_t)1"),
              IsError("C-style cast from 'int' to 'nullptr_t' (canonically "
                      "referred to as 'std::nullptr_t')"
                      " is not allowed"));
  EXPECT_THAT(Eval("(nullptr_t)ap"),
              IsError("C-style cast from 'int *' to 'nullptr_t' (canonically "
                      "referred to as 'std::nullptr_t')"
                      " is not allowed"));
}

TEST_F(EvalTest, TestCStyleCastNullptrType) {
  if (Is32Bit()) {
    EXPECT_THAT(Eval("(int)nullptr"), IsOk());
  } else {
    EXPECT_THAT(
        Eval("(int)nullptr"),
        IsError("cast from pointer to smaller type 'int' loses information"));
  }
  EXPECT_THAT(Eval("(uint64_t)nullptr"), IsEqual("0"));

  EXPECT_THAT(Eval("(void*)nullptr"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("(char*)nullptr"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
}

TEST_F(EvalTest, TestCStyleCastArray) {
  EXPECT_THAT(Eval("(int*)arr_1d"), IsOk());
  EXPECT_THAT(Eval("(char*)arr_1d"), IsOk());
  EXPECT_THAT(Eval("((char*)arr_1d)[0]"), IsEqual("'\\x01'"));
  EXPECT_THAT(Eval("((char*)arr_1d)[1]"), IsEqual("'\\0'"));

  // 2D arrays.
  EXPECT_THAT(Eval("(int*)arr_2d"), IsOk());
  EXPECT_THAT(Eval("((int*)arr_2d)[1]"), IsEqual("2"));
  EXPECT_THAT(Eval("((int*)arr_2d)[2]"), IsEqual("3"));
  EXPECT_THAT(Eval("((int*)arr_2d[1])[1]"), IsEqual("5"));
}

TEST_F(EvalTest, TestArrayDereference) {
  EXPECT_THAT(Eval("*arr_1d"), IsEqual("1"));
  EXPECT_THAT(Eval("&*arr_1d"), IsOk());
  EXPECT_THAT(Eval("*(arr_1d + 1)"), IsEqual("2"));

  EXPECT_THAT(Eval("(int*)*arr_2d"), IsOk());
  EXPECT_THAT(Eval("&*arr_2d"), IsOk());
  EXPECT_THAT(Eval("**arr_2d"), IsEqual("1"));
  EXPECT_THAT(Eval("*arr_2d[1]"), IsEqual("4"));
  EXPECT_THAT(Eval("(*arr_2d)[1]"), IsEqual("2"));
  EXPECT_THAT(Eval("**(arr_2d + 1)"), IsEqual("4"));
  EXPECT_THAT(Eval("*(*(arr_2d + 1) + 1)"), IsEqual("5"));
}

TEST_F(EvalTest, TestCStyleCastReference) {
  EXPECT_THAT(Eval("((InnerFoo&)arr_1d[1]).a"), IsEqual("2"));
  EXPECT_THAT(Eval("((InnerFoo&)arr_1d[1]).b"), IsEqual("3"));

  EXPECT_THAT(Eval("(int&)arr_1d[0]"), IsEqual("1"));
  EXPECT_THAT(Eval("(int&)arr_1d[1]"), IsEqual("2"));

  EXPECT_THAT(Eval("(int&)0"),
              IsError("C-style cast from rvalue to reference type 'int &'"));
  EXPECT_THAT(Eval("&(int&)arr_1d"), IsOk());
}

TEST_F(EvalTest, TestCxxStaticCast) {
  // Cast to scalars.
  EXPECT_THAT(Eval("static_cast<int>(1.1)"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<double>(1)"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<char>(128)"), IsEqual("'\\x80'"));
  EXPECT_THAT(Eval("static_cast<bool>(nullptr)"), IsEqual("false"));
  EXPECT_THAT(Eval("static_cast<bool>((int*)0)"), IsEqual("false"));
  EXPECT_THAT(Eval("static_cast<bool>(arr)"), IsEqual("true"));
  EXPECT_THAT(Eval("static_cast<int>(u_enum)"), IsEqual("2"));
  EXPECT_THAT(Eval("static_cast<float>(s_enum)"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<td_int_t>(5.3)"), IsEqual("5"));
  EXPECT_THAT(Eval("static_cast<td_int_t>(4)"), IsEqual("4"));
  EXPECT_THAT(Eval("static_cast<int>(td_int)"), IsEqual("13"));

  EXPECT_THAT(Eval("static_cast<long long>(nullptr)"),
              IsError("static_cast from 'std::nullptr_t' to 'long long' is not "
                      "allowed"));

  EXPECT_THAT(
      Eval("static_cast<long long>(ptr)"),
      IsError("static_cast from 'int *' to 'long long' is not allowed"));
  EXPECT_THAT(
      Eval("static_cast<long long>(arr)"),
      IsError("static_cast from 'int *' to 'long long' is not allowed"));
  EXPECT_THAT(
      Eval("static_cast<int>(parent)"),
      IsError(
          "cannot convert 'CxxParent' to 'int' without a conversion operator"));
  EXPECT_THAT(
      Eval("static_cast<long long>(base)"),
      IsError("static_cast from 'CxxBase *' to 'long long' is not allowed"));

  // Cast to enums.
  EXPECT_THAT(Eval("static_cast<UEnum>(0)"), IsEqual("kUZero"));
  EXPECT_THAT(Eval("static_cast<UEnum>(s_enum)"), IsEqual("kUOne"));
  EXPECT_THAT(Eval("static_cast<UEnum>(2.1)"), IsEqual("kUTwo"));
  EXPECT_THAT(Eval("static_cast<SEnum>(true)"), IsEqual("kSOne"));
  EXPECT_THAT(Eval("static_cast<SEnum>(0.4f)"), IsEqual("kSZero"));
  EXPECT_THAT(Eval("static_cast<SEnum>(td_senum)"), IsEqual("kSOne"));
  EXPECT_THAT(Eval("static_cast<td_senum_t>(UEnum::kUOne)"), IsEqual("kSOne"));

  EXPECT_THAT(
      Eval("static_cast<UEnum>(nullptr)"),
      IsError("static_cast from 'std::nullptr_t' to 'UEnum' is not allowed"));

  EXPECT_THAT(Eval("static_cast<UEnum>(ptr)"),
              IsError("static_cast from 'int *' to 'UEnum' is not allowed"));
  EXPECT_THAT(
      Eval("static_cast<SEnum>(parent)"),
      IsError("static_cast from 'CxxParent' to 'SEnum' is not allowed"));

  // Cast to pointers.
  EXPECT_THAT(Eval("static_cast<char*>(0)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("static_cast<long*>(nullptr)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("*static_cast<int*>(arr)"), IsEqual("1"));
  EXPECT_THAT(Eval("*static_cast<td_int_ptr_t>(arr)"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<void*>(ptr)"), IsOk());
  EXPECT_THAT(Eval("static_cast<int*>((void*)4)"),
              IsEqual(Is32Bit() ? "0x00000004" : "0x0000000000000004"));
  EXPECT_THAT(Eval("static_cast<long*>(ptr)"),
              IsError("static_cast from 'int *' to 'long *' is not allowed"));
  EXPECT_THAT(Eval("static_cast<float*>(arr)"),
              IsError("static_cast from 'int *' to 'float *' is not allowed"));

  // Cast to nullptr.
  EXPECT_THAT(Eval("static_cast<nullptr_t>((int)0)"),
              IsError("static_cast from 'int' to 'nullptr_t' (canonically "
                      "referred to as 'std::nullptr_t')"
                      " is not allowed"));
  EXPECT_THAT(Eval("static_cast<nullptr_t>((void*)0)"),
              IsError("static_cast from 'void *' to 'nullptr_t' (canonically "
                      "referred to as 'std::nullptr_t')"
                      " is not allowed"));

  // Cast to references.
  EXPECT_THAT(Eval("static_cast<int&>(parent.b)"), IsEqual("2"));
  EXPECT_THAT(Eval("&static_cast<int&>(parent.b)"), IsOk());
  EXPECT_THAT(
      Eval("static_cast<int&>(parent.c)"),
      IsError(
          "static_cast from 'long long' to 'int &' is not implemented yet"));
  EXPECT_THAT(Eval("static_cast<int&>(5)"),
              IsError("static_cast from rvalue of type 'int' to reference type "
                      "'int &' is not implemented yet"));

  // Invalid expressions.
  EXPECT_THAT(Eval("static_cast<1>(1)"),
              IsError("type name requires a specifier or qualifier"));
  EXPECT_THAT(Eval("static_cast<>(1)"),
              IsError("type name requires a specifier or qualifier"));
  EXPECT_THAT(Eval("static_cast<parent>(1)"),
              IsError("unknown type name 'parent'"));
  EXPECT_THAT(Eval("static_cast<T_1<int> CxxParent>(1)"),
              IsError("two or more data types in declaration of 'type name'"));

  // Cast to nullptr.
  GTEST_SKIP() << "Segfault when retrieving result value in the matcher";
  EXPECT_THAT(Eval("static_cast<nullptr_t>(nullptr)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("static_cast<nullptr_t>(0)"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
}

TEST_F(EvalTest, TestCastDerivedToBase) {
  EXPECT_THAT(Eval("static_cast<CxxA*>(&a)->a"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<CxxA*>(&c)->a"), IsEqual("3"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&c)->b"), IsEqual("4"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&c)->c"),
              IsError("no member named 'c' in 'CxxB'"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&e)->b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxC*>(&e)->a"), IsEqual("7"));
  EXPECT_THAT(Eval("static_cast<CxxC*>(&e)->b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxC*>(&e)->c"), IsEqual("9"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&d)"),
              IsError("static_cast from 'CxxD *' to 'CxxB *', which are not "
                      "related by inheritance, is not allowed"));

  // Cast via virtual inheritance.
  EXPECT_THAT(Eval("static_cast<CxxA*>(&vc)->a"), IsEqual("12"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&vc)->b"), IsEqual("13"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&vc)->c"),
              IsError("no member named 'c' in 'CxxB'"));
  EXPECT_THAT(Eval("static_cast<CxxB*>(&ve)->b"), IsEqual("16"));
  EXPECT_THAT(Eval("static_cast<CxxC*>(&ve)"),
              IsError("static_cast from 'CxxVE *' to 'CxxC *', which are not "
                      "related by inheritance, is not allowed"));

  // Same with references.
  EXPECT_THAT(Eval("static_cast<CxxA&>(a).a"), IsEqual("1"));
  EXPECT_THAT(Eval("static_cast<CxxA&>(c).a"), IsEqual("3"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(c).b"), IsEqual("4"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(c).c"),
              IsError("no member named 'c' in 'CxxB'"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(e).b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxC&>(e).a"), IsEqual("7"));
  EXPECT_THAT(Eval("static_cast<CxxC&>(e).b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxC&>(e).c"), IsEqual("9"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(d)"),
              IsError("static_cast from 'CxxD' to 'CxxB &', which are not "
                      "related by inheritance, is not allowed"));

  EXPECT_THAT(Eval("static_cast<CxxA&>(vc).a"), IsEqual("12"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(vc).b"), IsEqual("13"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(vc).c"),
              IsError("no member named 'c' in 'CxxB'"));
  EXPECT_THAT(Eval("static_cast<CxxB&>(ve).b"), IsEqual("16"));
  EXPECT_THAT(Eval("static_cast<CxxC&>(ve)"),
              IsError("static_cast from 'CxxVE' to 'CxxC &', which are not "
                      "related by inheritance, is not allowed"));
}

TEST_F(EvalTest, TestCastBaseToDerived) {
  EXPECT_THAT(Eval("static_cast<CxxE*>(e_as_b)->a"), IsEqual("7"));
  EXPECT_THAT(Eval("static_cast<CxxE*>(e_as_b)->b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxE*>(e_as_b)->c"), IsEqual("9"));
  EXPECT_THAT(Eval("static_cast<CxxE*>(e_as_b)->d"), IsEqual("10"));
  EXPECT_THAT(Eval("static_cast<CxxE*>(e_as_b)->e"), IsEqual("11"));

  // Same with references.
  EXPECT_THAT(Eval("static_cast<CxxE&>(*e_as_b).a"), IsEqual("7"));
  EXPECT_THAT(Eval("static_cast<CxxE&>(*e_as_b).b"), IsEqual("8"));
  EXPECT_THAT(Eval("static_cast<CxxE&>(*e_as_b).c"), IsEqual("9"));
  EXPECT_THAT(Eval("static_cast<CxxE&>(*e_as_b).d"), IsEqual("10"));
  EXPECT_THAT(Eval("static_cast<CxxE&>(*e_as_b).e"), IsEqual("11"));

  // Base-to-derived conversion isn't possible for virtually inhertied types.
  EXPECT_THAT(
      Eval("static_cast<CxxVE*>(ve_as_b)"),
      IsError("cannot cast 'CxxB *' to 'CxxVE *' via virtual base 'CxxB'"));
  EXPECT_THAT(
      Eval("static_cast<CxxVE&>(*ve_as_b)"),
      IsError("cannot cast 'CxxB' to 'CxxVE &' via virtual base 'CxxB'"));
}

TEST_F(EvalTest, TestCxxDynamicCast) {
  // LLDB doesn't support `dynamic_cast` in the expression evaluator.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("dynamic_cast<int>(0)"),
              IsError("invalid target type 'int' for dynamic_cast"));
  EXPECT_THAT(Eval("dynamic_cast<int*>(0)"),
              IsError("'int' is not a class type"));
  EXPECT_THAT(
      Eval("dynamic_cast<CxxBase*>(1.1)"),
      IsError(
          "cannot use dynamic_cast to convert from 'double' to 'CxxBase *'"));
  EXPECT_THAT(Eval("dynamic_cast<CxxBase*>((int*)0)"),
              IsError("'int' is not a class type"));
  EXPECT_THAT(Eval("dynamic_cast<CxxVirtualParent*>(base)"),
              IsError("'CxxBase' is not polymorphic"));
  EXPECT_THAT(Eval("dynamic_cast<CxxVirtualParent*>(v_base)"),
              IsError("dynamic_cast is not supported in this context"));
}

TEST_F(EvalTest, TestCxxReinterpretCast) {
  // Integers and enums can be converted to its own type.
  EXPECT_THAT(Eval("reinterpret_cast<bool>(true)"), IsEqual("true"));
  EXPECT_THAT(Eval("reinterpret_cast<int>(5)"), IsEqual("5"));
  EXPECT_THAT(Eval("reinterpret_cast<td_int_t>(6)"), IsEqual("6"));
  EXPECT_THAT(Eval("reinterpret_cast<int>(td_int)"), IsEqual("13"));
  EXPECT_THAT(Eval("reinterpret_cast<long long>(100LL)"), IsEqual("100"));
  EXPECT_THAT(Eval("reinterpret_cast<UEnum>(u_enum)"), IsEqual("kUTwo"));
  EXPECT_THAT(Eval("reinterpret_cast<SEnum>(s_enum)"), IsEqual("kSOne"));
  EXPECT_THAT(Eval("reinterpret_cast<td_senum_t>(s_enum)"), IsEqual("kSOne"));
  // Other scalar/enum to scalar/enum casts aren't allowed.
  EXPECT_THAT(
      Eval("reinterpret_cast<int>(5U)"),
      IsError("reinterpret_cast from 'unsigned int' to 'int' is not allowed"));
  EXPECT_THAT(Eval("reinterpret_cast<int>(3.14f)"),
              IsError("reinterpret_cast from 'float' to 'int' is not allowed"));
  EXPECT_THAT(
      Eval("reinterpret_cast<double>(2.71)"),
      IsError("reinterpret_cast from 'double' to 'double' is not allowed"));
  EXPECT_THAT(Eval("reinterpret_cast<int>(s_enum)"),
              IsError("reinterpret_cast from 'SEnum' to 'int' is not allowed"));
  EXPECT_THAT(Eval("reinterpret_cast<UEnum>(0)"),
              IsError("reinterpret_cast from 'int' to 'UEnum' is not allowed"));
  EXPECT_THAT(
      Eval("reinterpret_cast<UEnum>(s_enum)"),
      IsError("reinterpret_cast from 'SEnum' to 'UEnum' is not allowed"));

  // Pointers should be convertible to large enough integral types.
  EXPECT_THAT(Eval("reinterpret_cast<long long>(ptr)"), IsOk());
  EXPECT_THAT(Eval("reinterpret_cast<long long>(arr)"), IsOk());
  EXPECT_THAT(Eval("reinterpret_cast<long long>(nullptr)"), IsEqual("0"));
  if (Is32Bit()) {
    EXPECT_THAT(Eval("reinterpret_cast<int>(ptr)"), IsOk());
    EXPECT_THAT(Eval("reinterpret_cast<td_int_t>(ptr)"), IsOk());
  } else {
    EXPECT_THAT(
        Eval("reinterpret_cast<int>(ptr)"),
        IsError("cast from pointer to smaller type 'int' loses information"));
    EXPECT_THAT(Eval("reinterpret_cast<td_int_t>(ptr)"),
                IsError("cast from pointer to smaller type 'td_int_t' ("
                        "canonically referred to as 'int') loses information"));
  }
  EXPECT_THAT(
      Eval("reinterpret_cast<bool>(arr)"),
      IsError("cast from pointer to smaller type 'bool' loses information"));
  EXPECT_THAT(
      Eval("reinterpret_cast<bool>(nullptr)"),
      IsError("cast from pointer to smaller type 'bool' loses information"));
#ifdef _WIN32
  EXPECT_THAT(
      Eval("reinterpret_cast<long>(ptr)"),
      IsError("cast from pointer to smaller type 'long' loses information"));
#else
  EXPECT_THAT(Eval("reinterpret_cast<long>(ptr)"), IsOk());
#endif

  // Integers, enums and pointers can be converted to pointers.
  EXPECT_THAT(Eval("reinterpret_cast<int*>(true)"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));
  EXPECT_THAT(Eval("reinterpret_cast<float*>(6)"),
              IsEqual(Is32Bit() ? "0x00000006" : "0x0000000000000006"));
  EXPECT_THAT(Eval("reinterpret_cast<void*>(s_enum)"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));
  EXPECT_THAT(Eval("reinterpret_cast<CxxBase*>(u_enum)"),
              IsEqual(Is32Bit() ? "0x00000002" : "0x0000000000000002"));
  EXPECT_THAT(Eval("reinterpret_cast<td_int_ptr_t>(ptr)"), IsOk());
  EXPECT_THAT(Eval("*reinterpret_cast<UEnum**>(ptr)"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000200000001"));
  EXPECT_THAT(Eval("*reinterpret_cast<int*>(arr)"), IsEqual("1"));
  EXPECT_THAT(Eval("*reinterpret_cast<long long*>(arr)"),
              IsEqual("8589934593")); // 8589934593 == 0x0000000200000001

  // L-values can be converted to reference type.
  EXPECT_THAT(Eval("reinterpret_cast<CxxBase&>(arr[0]).a"), IsEqual("1"));
  EXPECT_THAT(Eval("reinterpret_cast<CxxBase&>(arr).b"), IsEqual("2"));
  EXPECT_THAT(Eval("reinterpret_cast<CxxParent&>(arr[0]).c"),
              IsEqual("17179869187")); // 17179869187 == 0x0000000400000003
  EXPECT_THAT(Eval("reinterpret_cast<CxxParent&>(arr).d"), IsEqual("5"));
  EXPECT_THAT(Eval("reinterpret_cast<int&>(parent)"), IsOk());
  EXPECT_THAT(Eval("reinterpret_cast<td_int_ref_t>(ptr)"), IsOk());
  EXPECT_THAT(
      Eval("reinterpret_cast<int&>(5)"),
      IsError("reinterpret_cast from rvalue to reference type 'int &'"));

  // Is result L-value or R-value?
  EXPECT_THAT(Eval("&reinterpret_cast<int&>(arr[0])"), IsOk());
  EXPECT_THAT(Eval("&reinterpret_cast<int>(arr[0])"),
              IsError("cannot take the address of an rvalue of type 'int'"));
  EXPECT_THAT(Eval("&reinterpret_cast<UEnum>(u_enum)"),
              IsError("cannot take the address of an rvalue of type 'UEnum'"));
  EXPECT_THAT(Eval("&reinterpret_cast<int*>(arr)"),
              IsError("cannot take the address of an rvalue of type 'int *'"));

  // Casting to nullptr_t or nullptr_t to pointer types isn't allowed.
  EXPECT_THAT(
      Eval("reinterpret_cast<void*>(nullptr)"),
      IsError("reinterpret_cast from 'std::nullptr_t' to 'void *' is not "
              "allowed"));
  GTEST_SKIP() << "Unknown error string mismatch";
  EXPECT_THAT(
      Eval("reinterpret_cast<nullptr_t>(ptr)"),
      IsError("reinterpret_cast from 'int *' to 'nullptr_t' "
              "(canonically referred to as 'std::nullptr_t') is not allowed"));
  EXPECT_THAT(
      Eval("reinterpret_cast<nullptr_t>(0)"),
      IsError("reinterpret_cast from 'int' to 'nullptr_t' "
              "(canonically referred to as 'std::nullptr_t') is not allowed"));
  EXPECT_THAT(
      Eval("reinterpret_cast<nullptr_t>(nullptr)"),
      IsError("reinterpret_cast from 'std::nullptr_t' to 'nullptr_t' "
              "(canonically referred to as 'std::nullptr_t') is not allowed"));
}

TEST_F(EvalTest, TestQualifiedId) {
  EXPECT_THAT(Eval("::ns::i"), IsEqual("1"));
  EXPECT_THAT(Eval("ns::i"), IsEqual("1"));
  EXPECT_THAT(Eval("::ns::ns::i"), IsEqual("2"));
  EXPECT_THAT(Eval("ns::ns::i"), IsEqual("2"));
}

TEST_F(EvalTest, TestStaticConstDeclaredInline) {
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("::outer::inner::Vars::inline_static"), IsEqual("1.5"));
  EXPECT_THAT(Eval("::outer::inner::Vars::static_constexpr"), IsEqual("2"));
  EXPECT_THAT(Eval("outer::inner::Vars::inline_static"), IsEqual("1.5"));
  EXPECT_THAT(Eval("outer::inner::Vars::static_constexpr"), IsEqual("2"));

  EXPECT_THAT(Eval("::outer::Vars::inline_static"), IsEqual("4.5"));
  EXPECT_THAT(Eval("::outer::Vars::static_constexpr"), IsEqual("5"));
  EXPECT_THAT(Eval("outer::Vars::inline_static"), IsEqual("4.5"));
  EXPECT_THAT(Eval("outer::Vars::static_constexpr"), IsEqual("5"));

  EXPECT_THAT(Eval("::Vars::inline_static"), XFail(IsEqual("7.5")));
  EXPECT_THAT(Eval("::Vars::static_constexpr"), XFail(IsEqual("8")));
  EXPECT_THAT(Eval("Vars::inline_static"), XFail(IsEqual("7.5")));
  EXPECT_THAT(Eval("Vars::static_constexpr"), XFail(IsEqual("8")));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestStaticConstDeclaredInlineScoped) {
  EXPECT_THAT(Scope("outer_inner_vars").Eval("inline_static"), IsEqual("1.5"));
  EXPECT_THAT(Scope("outer_inner_vars").Eval("static_constexpr"), IsEqual("2"));
  EXPECT_THAT(Scope("outer_vars").Eval("inline_static"), IsEqual("4.5"));
  EXPECT_THAT(Scope("outer_vars").Eval("static_constexpr"), IsEqual("5"));
  EXPECT_THAT(Scope("vars").Eval("inline_static"), IsEqual("7.5"));
  EXPECT_THAT(Scope("vars").Eval("inline_static"), IsEqual("8"));
}
#endif

TEST_F(EvalTest, TestStaticConstDeclaredOutsideTheClass) {
#if LLVM_VERSION_MAJOR < 12
  // Upstream LLDB doesn't handle static const variables.
  this->compare_with_lldb_ = false;
#endif

  EXPECT_THAT(Eval("::outer::inner::Vars::static_const"), IsEqual("3"));
  EXPECT_THAT(Eval("outer::inner::Vars::static_const"), IsEqual("3"));
  EXPECT_THAT(Eval("::outer::Vars::static_const"), IsEqual("6"));
  EXPECT_THAT(Eval("outer::Vars::static_const"), IsEqual("6"));
  EXPECT_THAT(Eval("::Vars::static_const"), XFail(IsEqual("9")));
  EXPECT_THAT(Eval("Vars::static_const"), XFail(IsEqual("9")));

  EXPECT_THAT(Eval("::outer::inner::Vars::Nested::static_const"),
              IsEqual("10"));
  EXPECT_THAT(Eval("outer::inner::Vars::Nested::static_const"), IsEqual("10"));
  EXPECT_THAT(Eval("::outer::Vars::Nested::static_const"), IsEqual("20"));
  EXPECT_THAT(Eval("outer::Vars::Nested::static_const"), IsEqual("20"));
  EXPECT_THAT(Eval("::Vars::Nested::static_const"), XFail(IsEqual("30")));
  EXPECT_THAT(Eval("Vars::Nested::static_const"), XFail(IsEqual("30")));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestStaticConstDeclaredOutsideTheClassScoped) {
  EXPECT_THAT(Scope("outer_inner_vars").Eval("static_const"), IsEqual("3"));
  EXPECT_THAT(Scope("outer_vars").Eval("static_const"), IsEqual("6"));
  EXPECT_THAT(Scope("vars").Eval("static_const"), IsEqual("9"));

  EXPECT_THAT(Scope("outer_inner_vars").Eval("Nested::static_const"),
              IsEqual("10"));
  EXPECT_THAT(Scope("outer_vars").Eval("Nested::static_const"), IsEqual("20"));
  EXPECT_THAT(Scope("vars").Eval("Nested::static_const"), IsEqual("30"));

  EXPECT_THAT(Scope("vars").Eval("::static_const"),
              IsError("use of undeclared identifier '::static_const'"));
  EXPECT_THAT(Scope("vars").Eval("::Nested::static_const"),
              IsError("use of undeclared identifier '::Nested::static_const'"));

  // Evaluate in value context where value is of alised type.
  EXPECT_THAT(Scope("my_outer_inner_vars").Eval("static_const"), IsEqual("3"));
  EXPECT_THAT(Scope("my_outer_vars").Eval("static_const"), IsEqual("6"));
  EXPECT_THAT(Scope("my_vars").Eval("static_const"), IsEqual("9"));

  EXPECT_THAT(Scope("my_outer_inner_vars").Eval("Nested::static_const"),
              IsEqual("10"));
  EXPECT_THAT(Scope("my_outer_vars").Eval("Nested::static_const"),
              IsEqual("20"));
  EXPECT_THAT(Scope("my_vars").Eval("Nested::static_const"), IsEqual("30"));

  EXPECT_THAT(Scope("my_outer_inner_vars").Eval("::static_const"),
              IsError("use of undeclared identifier '::static_const'"));
  EXPECT_THAT(Scope("my_vars").Eval("::Nested::static_const"),
              IsError("use of undeclared identifier '::Nested::static_const'"));
}
#endif

TEST_F(EvalTest, TestBasicTypeDeclaration) {
  EXPECT_THAT(Eval("(char)65"), IsEqual("'A'"));
  EXPECT_THAT(Eval("(char unsigned)65"), IsEqual("'A'"));
  EXPECT_THAT(Eval("(signed char)65"), IsEqual("'A'"));
#ifndef __EMSCRIPTEN__
  if constexpr (sizeof(wchar_t) == 2) {
    // Size of "wchar_t" is 2 bytes on Windows.
    EXPECT_THAT(Eval("(wchar_t)0x4141"), IsEqual("AA"));
  } else {
    // Size of "wchar_t" is 4 bytes on Linux.
    EXPECT_THAT(Eval("(wchar_t)0x41414141"), IsEqual("AAAA"));
  }
  EXPECT_THAT(Eval("(char16_t)0x4141"), IsEqual("U+4141"));
  EXPECT_THAT(Eval("(char32_t)0x4141"), IsEqual("U+0x00004141"));
#endif
  EXPECT_THAT(Eval("(int short)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(short int)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(short)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(unsigned short)-1"), IsEqual("65535"));
  EXPECT_THAT(Eval("(short unsigned)-1"), IsEqual("65535"));
  EXPECT_THAT(Eval("(int short unsigned)-1"), IsEqual("65535"));
  EXPECT_THAT(Eval("(int)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(signed int)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(signed)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(unsigned)-1"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("(int unsigned)-1"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("(long)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(signed long)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(long int signed)-1"), IsEqual("-1"));
  if constexpr (sizeof(long) == 4) {
    // Size of "long" is 4 bytes on Windows.
    EXPECT_THAT(Eval("(unsigned long)-1"), IsEqual("4294967295"));
    EXPECT_THAT(Eval("(int long unsigned)-1"), IsEqual("4294967295"));
  } else {
    // Size of "long" is 8 bytes on Linux.
    EXPECT_THAT(Eval("(unsigned long)-1"), IsEqual("18446744073709551615"));
    EXPECT_THAT(Eval("(int long unsigned)-1"), IsEqual("18446744073709551615"));
  }
  EXPECT_THAT(Eval("(long long)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(long long int)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(int signed long long)-1"), IsEqual("-1"));
  EXPECT_THAT(Eval("(long int long unsigned)-1"),
              IsEqual("18446744073709551615"));
  EXPECT_THAT(Eval("(int long unsigned long)-1"),
              IsEqual("18446744073709551615"));
  EXPECT_THAT(Eval("(unsigned long long)-1"), IsEqual("18446744073709551615"));

  EXPECT_THAT(Eval("(float)1.5"), IsEqual("1.5"));
  EXPECT_THAT(Eval("(double)1.5"), IsEqual("1.5"));
#ifdef _WIN32
  // Casting to "long double" results in "NaN" on Linux.
  EXPECT_THAT(Eval("(long double)1.5"), IsEqual("1.5"));
  EXPECT_THAT(Eval("(double long)1.5"), IsEqual("1.5"));
#endif
  EXPECT_THAT(Eval("(bool)1.5"), IsEqual("true"));

  EXPECT_THAT(Eval("(void*)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("(unsigned**)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  EXPECT_THAT(
      Eval("(int int)0"),
      IsError("cannot combine with previous 'int' declaration specifier\n"
              "(int int)0\n"
              "     ^"));
  EXPECT_THAT(
      Eval("(char int)0"),
      IsError("cannot combine with previous 'char' declaration specifier"));
  EXPECT_THAT(
      Eval("(int char)0"),
      IsError("cannot combine with previous 'int' declaration specifier"));
  EXPECT_THAT(
      Eval("(long long long)0"),
      IsError(
          "cannot combine with previous 'long long' declaration specifier"));
  EXPECT_THAT(
      Eval("(long long double)0"),
      IsError(
          "cannot combine with previous 'long long' declaration specifier"));
  EXPECT_THAT(
      Eval("(long double long)0"),
      IsError(
          "cannot combine with previous 'long double' declaration specifier"));
  EXPECT_THAT(Eval("(unsigned long double)0"),
              IsError("'double' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(long double signed)0"),
              IsError("'long double' cannot be signed or unsigned"));
  EXPECT_THAT(
      Eval("(short float)0"),
      IsError("cannot combine with previous 'short' declaration specifier"));
  EXPECT_THAT(
      Eval("(unsigned signed)0"),
      IsError("cannot combine with previous 'unsigned' declaration specifier"));
  EXPECT_THAT(
      Eval("(unsigned unsigned)0"),
      IsError("cannot combine with previous 'unsigned' declaration specifier"));
  EXPECT_THAT(Eval("(signed wchar_t)0"),
              IsError("'wchar_t' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(signed char16_t)0"),
              IsError("'char16_t' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(signed char32_t)0"),
              IsError("'char32_t' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(unsigned float)0"),
              IsError("'float' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(unsigned double)0"),
              IsError("'double' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(unsigned bool)0"),
              IsError("'bool' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(unsigned void)0"),
              IsError("'void' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(bool unsigned)0"),
              IsError("'bool' cannot be signed or unsigned"));
  EXPECT_THAT(Eval("(bool signed)0"),
              IsError("'bool' cannot be signed or unsigned"));

  // Error reporting works with other kinds of expression.
  EXPECT_THAT(
      Eval("static_cast<int int>(0)"),
      IsError("cannot combine with previous 'int' declaration specifier"));
  EXPECT_THAT(
      Eval("sizeof(int int)"),
      IsError("cannot combine with previous 'int' declaration specifier"));
}

TEST_F(EvalTest, TestUserTypeDeclaration) {
  EXPECT_THAT(Eval("(unsigned mylong)0"),
              IsError("cannot combine with previous declaration specifier"));
  EXPECT_THAT(Eval("static_cast<mylong mylong>(0)"),
              IsError("two or more data types in declaration of 'type name'"));
  EXPECT_THAT(Eval("static_cast<mylong unsigned>(0)"),
              IsError("cannot combine with previous declaration specifier"));
  // TODO: Should this be a type name error instead?
  EXPECT_THAT(Eval("(mylong unsigned)0"),
              IsError("undeclared identifier 'mylong'"));
}

TEST_F(EvalTest, TestTemplateTypes) {
  // Template types lookup doesn't work well in the upstream LLDB.
  this->compare_with_lldb_ = false;
#ifndef __EMSCRIPTEN__
  // Get the pointer value and use it to check the expressions with lldb-eval.
  auto expected = frame_.EvaluateExpression("p").GetValue();

  for (std::string arg : {"int", "int*", "int**", "int&", "int*&", "double"}) {
    EXPECT_THAT(Eval("(T_1<" + arg + ">*)p"), IsEqual(expected));
    EXPECT_THAT(Eval("(::T_1<" + arg + ">*)p"), IsEqual(expected));
  }
  EXPECT_THAT(Eval("(T_2<int, char>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::T_2<int, char>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(T_2<char, int>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::T_2<char, int>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(T_2<T_1<int>, T_1<char> >*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::T_2<T_1<int>, T_1<char> >*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(T_2<T_1<T_1<int> >, T_1<char> >*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::T_2<T_1<T_1<int> >, T_1<char> >*)p"), IsEqual(expected));

  EXPECT_THAT(Eval("(ns::T_1<int>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::ns::T_1<int>*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(ns::T_1<ns::T_1<int> >*)p"), IsEqual(expected));
  EXPECT_THAT(Eval("(::ns::T_1<ns::T_1<int> >*)p"), IsEqual(expected));
#endif
  EXPECT_THAT(
      Eval("ns::T_1<ns::T_1<int> >::cx"),
      IsError("use of undeclared identifier 'ns::T_1<ns::T_1<int> >::cx'"));
  EXPECT_THAT(Eval("T_1<int>::cx"), XFail(IsEqual("24")));
  EXPECT_THAT(Eval("T_1<double>::cx"), XFail(IsEqual("42")));
  EXPECT_THAT(Eval("ns::T_1<int>::cx"), IsEqual("64"));

  for (std::string arg : {"int", "int*", "int**", "int&", "int*&"}) {
    EXPECT_THAT(Eval("(T_1<" + arg + ">::myint)1.2"), IsEqual("1.2"));
    EXPECT_THAT(Eval("(::T_1<" + arg + ">::myint)1.2"), IsEqual("1.2"));
    EXPECT_THAT(Eval("(T_1<T_1<" + arg + "> >::myint)1.2"), IsEqual("1.2"));
    EXPECT_THAT(Eval("(::T_1<T_1<" + arg + "> >::myint)1.2"), IsEqual("1.2"));

    EXPECT_THAT(Eval("(ns::T_1<" + arg + ">::myint)1.1"), IsEqual("1"));
    EXPECT_THAT(Eval("(::ns::T_1<" + arg + ">::myint)1.1"), IsEqual("1"));
    EXPECT_THAT(Eval("(ns::T_1<T_1<" + arg + "> >::myint)1.1"), IsEqual("1"));
    EXPECT_THAT(Eval("(::ns::T_1<T_1<" + arg + "> >::myint)1.1"), IsEqual("1"));
    EXPECT_THAT(Eval("(ns::T_1<ns::T_1<" + arg + "> >::myint)1.1"),
                IsEqual("1"));
    EXPECT_THAT(Eval("(::ns::T_1<ns::T_1<" + arg + "> >::myint)1.1"),
                IsEqual("1"));
  }

  EXPECT_THAT(Eval("(T_2<int, char>::myint)1.1f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(::T_2<int, char>::myint)1.1f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(T_2<int*, char&>::myint)1.1f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(::T_2<int&, char*>::myint)1.1f"), IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(T_2<T_1<T_1<int> >, T_1<char> >::myint)1.1"),
              IsEqual("1.10000002"));
  EXPECT_THAT(Eval("(::T_2<T_1<T_1<int> >, T_1<char> >::myint)1.1"),
              IsEqual("1.10000002"));
}

TEST_F(EvalTest, TestTemplateCpp11) {
  // Template types lookup doesn't work well in the upstream LLDB.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("(T_1<T_1<int>>::myint)1"), XFail(IsEqual("1")));
  EXPECT_THAT(Eval("(T_1<T_1<T_1<int>>>::myint)2"), XFail(IsEqual("2")));
  EXPECT_THAT(Eval("(T_2<T_1<T_1<int>>, T_1<char>>::myint)1.5"),
              XFail(IsEqual("1.5")));

  // Here T_1 is a local variable.
  EXPECT_THAT(Eval("T_1<2>1"), IsEqual("false"));  // (p < 2) > 1
  // EXPECT_THAT(Eval("T_1<2>>1"), IsEqual("false")); // (p < 2) >> 1
  EXPECT_THAT(Eval("T_1<2>>1"),
              IsError("<expr:1:7>: Unexpected token: <'>' (greater)>"));
  // And here it's a template.
  EXPECT_THAT(Eval("T_1<int>::cx + 1"), XFail(IsEqual("25")));
}

TEST_F(EvalTest, TestTemplateWithNumericArguments) {
  // Template types lookup doesn't work well in the upstream LLDB.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("(Allocator<4>*)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("(TArray<int, Allocator<4> >::ElementType*)0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  // Test C++11's ">>" syntax.
  EXPECT_THAT(Eval("(TArray<int, Allocator<4>>::ElementType*)0"),
              XFail(IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000")));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestValueScope) {
  EXPECT_THAT(Scope("var").Eval("x_"), IsEqual("1"));
  EXPECT_THAT(Scope("var").Eval("y_"), IsEqual("2.5"));
  EXPECT_THAT(Scope("var").Eval("z_"),
              IsError("use of undeclared identifier 'z_'"));

  // In "value" scope `this` refers to the scope object.
  EXPECT_THAT(Scope("var").Eval("this->y_"), IsEqual("2.5"));
  EXPECT_THAT(Scope("var").Eval("(*this).y_"), IsEqual("2.5"));

  // Test for the "artificial" value, i.e. created by the expression.
  lldb::SBValue scope_var = frame_.EvaluateExpressionViaDIL(
      "(test_scope::Value&)bytes", lldb::eNoDynamicValues);
  lldb::SBError error = scope_var.GetError();
  EXPECT_TRUE(scope_var.IsValid());
  EXPECT_TRUE(error.Success());

  EvaluatorHelper scope(scope_var, true, false);
  EXPECT_THAT(scope.Eval("this->y_"), IsEqual("2.5"));
  EXPECT_THAT(scope.Eval("(*this).y_"), IsEqual("2.5"));

  EXPECT_THAT(Eval("x_"), IsError("use of undeclared identifier 'x_'"));
  EXPECT_THAT(Eval("y_"), IsError("use of undeclared identifier 'y_'"));
  EXPECT_THAT(Eval("z_"), IsEqual("3"));

  // In the frame context `this` is not available here.
  EXPECT_THAT(
      Eval("this->y_"),
      IsError("invalid use of 'this' outside of a non-static member function"));
  EXPECT_THAT(
      Eval("(*this)->y_"),
      IsError("invalid use of 'this' outside of a non-static member function"));

  EXPECT_THAT(Scope("var").Eval("this - (test_scope::Value*)this"),
              IsEqual("0"));
}

TEST_F(EvalTest, DISABLED_TestReferenceScope) {
  // Member access in "reference" context doesn't work in LLDB.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Scope("var_ref").Eval("x_"), IsEqual("1"));
  EXPECT_THAT(Scope("var_ref").Eval("y_"), IsEqual("2.5"));
  EXPECT_THAT(Scope("var_ref").Eval("z_"),
              IsError("use of undeclared identifier 'z_'"));
  EXPECT_THAT(Scope("var_ref").Eval("this"), IsOk());
  EXPECT_THAT(Scope("var_ref").Eval("this->y_"), IsEqual("2.5"));
  EXPECT_THAT(Scope("var_ref").Eval("(*this).y_"), IsEqual("2.5"));
  EXPECT_THAT(Scope("var_ref").Eval("ValueEnum::B"), IsEqual("B"));
  EXPECT_THAT(Scope("var_ref").Eval("static_var"), IsEqual("3.5"));
  EXPECT_THAT(Scope("var_ref").Eval("this->static_var"),
              IsError("no member named 'static_var' in 'test_scope::Value'"));
}
#endif

TEST_F(EvalTest, TestBitField) {
  EXPECT_THAT(Eval("bf.a"), IsEqual("1023"));
  EXPECT_THAT(Eval("bf.b"), IsEqual("9"));
  EXPECT_THAT(Eval("bf.c"), IsEqual("false"));
  EXPECT_THAT(Eval("bf.d"), IsEqual("true"));

  // Perform an operation to ensure we actually read the value.
  EXPECT_THAT(Eval("0 + bf.a"), IsEqual("1023"));
  EXPECT_THAT(Eval("0 + bf.b"), IsEqual("9"));
  EXPECT_THAT(Eval("0 + bf.c"), IsEqual("0"));
  EXPECT_THAT(Eval("0 + bf.d"), IsEqual("1"));

  EXPECT_THAT(Eval("abf.a"), IsEqual("1023"));
  EXPECT_THAT(Eval("abf.b"), IsEqual("'\\x0f'"));
  EXPECT_THAT(Eval("abf.c"), IsEqual("3"));

  EXPECT_THAT(Eval("abf.a + 0"), IsEqual("1023"));
  EXPECT_THAT(Eval("abf.b + 0"), IsEqual("15"));
  EXPECT_THAT(Eval("abf.c + 0"), IsEqual("3"));

  // Address-of is not allowed for bit-fields.
  EXPECT_THAT(Eval("&bf.a"), IsError("address of bit-field requested"));
  EXPECT_THAT(Eval("&(true ? bf.a : bf.a)"),
              IsError("address of bit-field requested"));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestBitFieldScoped) {
  EXPECT_THAT(Scope("bf").Eval("a"), IsEqual("1023"));
  EXPECT_THAT(Scope("bf").Eval("b"), IsEqual("9"));
  EXPECT_THAT(Scope("bf").Eval("c"), IsEqual("false"));
  EXPECT_THAT(Scope("bf").Eval("d"), IsEqual("true"));
  EXPECT_THAT(Scope("bf").Eval("0 + a"), IsEqual("1023"));
  // TODO: Enable type comparison after fixing bitfield promotion in value
  // context.
  EXPECT_THAT(Scope("bf").Eval("0 + b"), IsEqual("9", /*compare_types*/
                                                 false));
  EXPECT_THAT(Scope("bf").Eval("0 + c"), IsEqual("0"));
  EXPECT_THAT(Scope("bf").Eval("0 + d"), IsEqual("1"));
  EXPECT_THAT(Scope("abf").Eval("a"), IsEqual("1023"));
  EXPECT_THAT(Scope("abf").Eval("b"), IsEqual("'\\x0f'"));
  EXPECT_THAT(Scope("abf").Eval("c"), IsEqual("3"));
  EXPECT_THAT(Scope("abf").Eval("0 + a"), IsEqual("1023"));
  EXPECT_THAT(Scope("abf").Eval("0 + b"), IsEqual("15"));
  EXPECT_THAT(Scope("abf").Eval("0 + c"), IsEqual("3"));
}
#endif

TEST_F(EvalTest, TestBitFieldPromotion) {
  EXPECT_THAT(Eval("bf.b - 10"), IsEqual("-1"));
  EXPECT_THAT(Eval("bf.e - 2"), IsEqual("-1"));
  EXPECT_THAT(Eval("bf.f - 2"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("bf.g - 2"), IsEqual("-1"));
  EXPECT_THAT(Eval("bf.h - 2"), IsEqual("-1"));
  EXPECT_THAT(Eval("bf.i - 2"), XFail(IsEqual("18446744073709551615")));
  EXPECT_THAT(Eval("bf.g - bf.b"), IsEqual("-8"));

  EXPECT_THAT(Eval("-(true ? bf.b : bf.a)"), IsEqual("-9"));
  EXPECT_THAT(Eval("-(true ? bf.b : bf.e)"), IsEqual("-9"));
  EXPECT_THAT(Eval("-(true ? bf.b : bf.f)"), IsEqual("4294967287"));
  EXPECT_THAT(Eval("-(true ? bf.b : bf.g)"), IsEqual("4294967287"));
  EXPECT_THAT(Eval("-(true ? bf.b : bf.h)"), IsEqual("-9"));

  if (HAS_METHOD(lldb::SBType, GetEnumerationIntegerType())) {
    EXPECT_THAT(Eval("bf.j - 2"), XFail(IsEqual("4294967295")));
    EXPECT_THAT(Eval("-(true ? bf.b : bf.j)"), IsEqual("4294967287"));
    EXPECT_THAT(Eval("-(true ? bf.e : bf.j)"), IsEqual("4294967295"));
  }

  // TODO: Repeat tests in the value context once the bitfield information is
  // correctly retrieved from identifier lookup.
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, TestBitFieldWithSideEffects) {
  this->compare_with_lldb_ = false;
  this->allow_side_effects_ = true;

  EXPECT_THAT(Eval("bf.b -= 10"), IsEqual("15"));
  EXPECT_THAT(Eval("bf.e -= 10"), IsEqual("-9"));
  EXPECT_THAT(Eval("bf.e++"), XFail(IsEqual("-9")));
  EXPECT_THAT(Eval("++bf.e"), IsEqual("-7"));

  // TODO: Enable test once the issue is fixed:
  // EXPECT_THAT(Eval("bf.b++"), IsEqual("15"));
}

TEST_F(EvalTest, DISABLED_TestContextVariables) {
  // Context variables don't exist yet.
  EXPECT_THAT(EvalWithContext("$var", vars_),
              IsError("use of undeclared identifier '$var'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var", vars_),
              IsError("use of undeclared identifier '$var'"));

  EXPECT_TRUE(CreateContextVariable("$var", "13"));
  EXPECT_THAT(EvalWithContext("$var", vars_), IsEqual("13"));
  EXPECT_THAT(EvalWithContext("$var + 2", vars_), IsEqual("15"));
  EXPECT_THAT(EvalWithContext("$var - s.a", vars_), IsEqual("3"));
  EXPECT_THAT(EvalWithContext("var", vars_),
              IsError("use of undeclared identifier 'var'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var", vars_), IsEqual("13"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var + 2", vars_), IsEqual("15"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var - a", vars_), IsEqual("3"));
  EXPECT_THAT(Scope("s").EvalWithContext("var", vars_),
              IsError("use of undeclared identifier 'var'"));

  // Context variable is a pointer.
  EXPECT_TRUE(CreateContextVariable("$ptr", "s.ptr"));
  EXPECT_THAT(EvalWithContext("$ptr == s.ptr", vars_), IsEqual("true"));
  EXPECT_THAT(EvalWithContext("*$ptr", vars_), IsEqual("'h'"));
  EXPECT_THAT(EvalWithContext("$ptr[1]", vars_), IsEqual("'e'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$ptr == ptr", vars_),
              IsEqual("true"));
  EXPECT_THAT(Scope("s").EvalWithContext("*$ptr", vars_), IsEqual("'h'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$ptr[1]", vars_), IsEqual("'e'"));

  EXPECT_THAT(EvalWithContext("$var + *$ptr", vars_), IsEqual("117"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var + *$ptr", vars_),
              IsEqual("117"));
}

TEST_F(EvalTest, DISABLED_TestContextVariablesSubset) {
  // All context variables that are created in this test are visible by LLDB.
  // Disable comparisons with LLDB to test subsets of created context variables.
  this->compare_with_lldb_ = false;

  EXPECT_TRUE(CreateContextVariable("$var", "13"));
  EXPECT_TRUE(CreateContextVariable("$ptr", "s.ptr"));

  // Evaluate without the context.
  EXPECT_THAT(Eval("$var"), IsError("use of undeclared identifier '$var'"));
  EXPECT_THAT(Eval("$var + 1"), IsError("use of undeclared identifier '$var'"));
  EXPECT_THAT(Scope("s").Eval("$var"),
              IsError("use of undeclared identifier '$var'"));
  EXPECT_THAT(Scope("s").Eval("$var + 1"),
              IsError("use of undeclared identifier '$var'"));

  std::unordered_map<std::string, lldb::SBValue> var;
  std::unordered_map<std::string, lldb::SBValue> ptr;
  var.emplace("$var", vars_["$var"]);
  ptr.emplace("$ptr", vars_["$ptr"]);

  EXPECT_THAT(EvalWithContext("$var + 0", var), IsEqual("13"));
  EXPECT_THAT(EvalWithContext("*$ptr", var),
              IsError("use of undeclared identifier '$ptr'"));
  EXPECT_THAT(EvalWithContext("$var + *$ptr", var),
              IsError("use of undeclared identifier '$ptr'"));
  EXPECT_THAT(EvalWithContext("$var + *$ptr", ptr),
              IsError("use of undeclared identifier '$var'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var + 0", var), IsEqual("13"));
  EXPECT_THAT(Scope("s").EvalWithContext("*$ptr", var),
              IsError("use of undeclared identifier '$ptr'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var + *$ptr", var),
              IsError("use of undeclared identifier '$ptr'"));
  EXPECT_THAT(Scope("s").EvalWithContext("$var + *$ptr", ptr),
              IsError("use of undeclared identifier '$var'"));
}
#endif

TEST_F(EvalTest, TestScopedEnum) {
  EXPECT_THAT(Eval("enum_foo"), IsEqual("kFoo"));
  EXPECT_THAT(Eval("enum_bar"), IsEqual("kBar"));

  EXPECT_THAT(Eval("enum_foo == enum_foo"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_foo != enum_foo"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_foo == enum_bar"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_foo < enum_bar"), IsEqual("true"));

  EXPECT_THAT(Eval("enum_foo == ScopedEnum::kFoo"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_foo == ScopedEnum::kBar"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_foo != ScopedEnum::kBar"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_foo < ScopedEnum::kBar"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_foo < enum_neg"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_neg < enum_bar"), IsEqual("true"));

  EXPECT_THAT(Eval("(ScopedEnum)0"), IsEqual("kFoo"));
  EXPECT_THAT(Eval("(ScopedEnum)1"), IsEqual("kBar"));
  EXPECT_THAT(Eval("(ScopedEnum)0.1"), IsEqual("kFoo"));
  EXPECT_THAT(Eval("(ScopedEnum)1.1"), IsEqual("kBar"));
  EXPECT_THAT(Eval("(ScopedEnum)-1"), IsOk());
  EXPECT_THAT(Eval("(ScopedEnum)-1.1"), XFail(IsOk()));
  EXPECT_THAT(Eval("(ScopedEnum)256"), IsOk());
  EXPECT_THAT(Eval("(ScopedEnum)257"), IsOk());
  EXPECT_THAT(Eval("(ScopedEnum)false"), IsEqual("kFoo"));
  EXPECT_THAT(Eval("(ScopedEnum)true"), IsEqual("kBar"));

  EXPECT_THAT(Eval("(int)enum_foo"), IsEqual("0"));
  EXPECT_THAT(Eval("(int)enum_neg"), IsEqual("-1"));
  EXPECT_THAT(Eval("(unsigned short)enum_neg"), IsEqual("65535"));
  EXPECT_THAT(Eval("(short)ScopedEnum::kBar"), IsEqual("1"));
  EXPECT_THAT(Eval("(short*)enum_neg"),
              XFail(IsEqual(Is32Bit() ? "0xffffffff" : "0xffffffffffffffff")));
  EXPECT_THAT(Eval("(char*)enum_u8_bar"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));
  EXPECT_THAT(Eval("(float)enum_bar"), IsEqual("1"));
  EXPECT_THAT(Eval("(float)enum_foo"), IsEqual("0"));
  EXPECT_THAT(Eval("(float)enum_neg"), IsEqual("-1"));
  EXPECT_THAT(Eval("(double)enum_neg"), IsEqual("-1"));
  EXPECT_THAT(Eval("(bool)enum_foo"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)enum_bar"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)enum_neg"), IsEqual("true"));
  EXPECT_THAT(Eval("(double)ScopedEnumUInt8::kBar"), IsEqual("1"));
  EXPECT_THAT(Eval("(ScopedEnum)ScopedEnum::kBar"), IsEqual("kBar"));

  // TODO: Enable the following test once the underlying enumeration type
  // becomes fully available. Information about underlying enumeration type
  // isn't available in LLDB 11 or lower, which are currently used by GitHub
  // actions.
  // EXPECT_THAT(Eval("(int)(ScopedEnumUInt8)enum_neg"), IsEqual("255"));
}

TEST_F(EvalTest, TestScopedEnumArithmetic) {
  if (!HAS_METHOD(lldb::SBType, IsScopedEnumerationType())) {
    GTEST_SKIP();
  }

  EXPECT_THAT(Eval("enum_foo == 1"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_foo + 1"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_foo * 2"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar / 2"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_foo % 2"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar & 2"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar | 0x01"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar ^ 0b11"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar >> 1"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("enum_bar << 1"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("1 >> enum_bar"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("1 << enum_bar"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("(int*)1 + enum_foo"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("(int*)5 - enum_foo"),
              IsError("invalid operands to binary expression"));
  EXPECT_THAT(Eval("+enum_foo"), IsError("invalid argument type"));
  EXPECT_THAT(Eval("-enum_foo"), IsError("invalid argument type"));
  EXPECT_THAT(Eval("~enum_foo"), IsError("invalid argument type"));
  EXPECT_THAT(Eval("!enum_foo"),
              IsError("invalid argument type 'ScopedEnum' to unary expression\n"
                      "!enum_foo\n"
                      "^"));
}

TEST_F(EvalTest, TestScopedEnumWithUnderlyingType) {
  EXPECT_THAT(Eval("(ScopedEnumUInt8)-1"), IsOk());
  EXPECT_THAT(Eval("(ScopedEnumUInt8)256"), IsEqual("kFoo"));
  EXPECT_THAT(Eval("(ScopedEnumUInt8)257"), IsEqual("kBar"));
}

TEST_F(EvalTest, TestUnscopedEnum) {
  EXPECT_THAT(Eval("enum_one"), IsEqual("kOne"));
  EXPECT_THAT(Eval("enum_two"), IsEqual("kTwo"));

  EXPECT_THAT(Eval("enum_one == enum_one"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one != enum_one"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one == enum_two"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one < enum_two"), IsEqual("true"));

  EXPECT_THAT(Eval("enum_one == UnscopedEnum::kOne"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one == UnscopedEnum::kTwo"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one != UnscopedEnum::kTwo"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one < UnscopedEnum::kTwo"), IsEqual("true"));

  EXPECT_THAT(Eval("(UnscopedEnum)0"), IsEqual("kZero"));
  EXPECT_THAT(Eval("(UnscopedEnum)1"), IsEqual("kOne"));
  EXPECT_THAT(Eval("(UnscopedEnum)0.1"), IsEqual("kZero"));
  EXPECT_THAT(Eval("(UnscopedEnum)1.1"), IsEqual("kOne"));
  EXPECT_THAT(Eval("(UnscopedEnum)-1"), IsOk());
  EXPECT_THAT(Eval("(UnscopedEnum)256"), IsOk());
  EXPECT_THAT(Eval("(UnscopedEnum)257"), IsOk());
  EXPECT_THAT(Eval("(UnscopedEnum)false"), IsEqual("kZero"));
  EXPECT_THAT(Eval("(UnscopedEnum)true"), IsEqual("kOne"));
  EXPECT_THAT(Eval("(UnscopedEnum)(UnscopedEnum)0"), IsEqual("kZero"));
  EXPECT_THAT(Eval("(void*)(UnscopedEnum)1"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));

  bool compare_types = HAS_METHOD(lldb::SBType, GetEnumerationIntegerType());

  EXPECT_THAT(Eval("enum_one == 1"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one + 1"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_one * 2"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_two / 2"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_one % 2"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two & 2"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_two | 0x01"), IsEqual("3", compare_types));
  EXPECT_THAT(Eval("enum_two ^ 0b11"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two >> 1"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two << 1"), IsEqual("4", compare_types));
  EXPECT_THAT(Eval("8 >> enum_two"), IsEqual("2"));
  EXPECT_THAT(Eval("1 << enum_two"), IsEqual("4"));
  // TODO: Enable type comparison after the bug is addressed in LLDB.
  EXPECT_THAT(Eval("UnscopedEnumUInt8::kTwoU8 << 1"),
              IsEqual("4", /*compare_types*/ false));
  EXPECT_THAT(Eval("UnscopedEnumInt8::kTwo8 << 1U"), IsEqual("4"));
  EXPECT_THAT(Eval("+enum_one"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("!enum_one"), IsEqual("false"));
  EXPECT_THAT(Eval("(int*)1 + enum_one"),
              IsEqual(Is32Bit() ? "0x00000005" : "0x0000000000000005"));
  EXPECT_THAT(Eval("(int*)5 - enum_one"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));

  // Use references.
  EXPECT_THAT(Eval("enum_one_ref"), IsEqual("kOne"));
  EXPECT_THAT(Eval("enum_two_ref"), IsEqual("kTwo"));
  EXPECT_THAT(Eval("enum_one_ref == enum_one"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref != enum_one"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one_ref == enum_two"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one_ref < enum_two"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref == UnscopedEnum::kOne"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref == UnscopedEnum::kTwo"), IsEqual("false"));
  EXPECT_THAT(Eval("enum_one_ref != UnscopedEnum::kTwo"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref < UnscopedEnum::kTwo"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref == 1"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_one_ref + 1"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_one_ref * 2"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_two_ref / 2"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_one_ref % 2"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two_ref & 2"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("enum_two_ref | 0x01"), IsEqual("3", compare_types));
  EXPECT_THAT(Eval("enum_two_ref ^ 0b11"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two_ref >> 1"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("enum_two_ref << 1"), IsEqual("4", compare_types));
  EXPECT_THAT(Eval("8 >> enum_two_ref"), IsEqual("2"));
  EXPECT_THAT(Eval("1 << enum_two_ref"), IsEqual("4"));
  EXPECT_THAT(Eval("+enum_one_ref"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("!enum_one_ref"), IsEqual("false"));
  EXPECT_THAT(Eval("(int*)1 + enum_one_ref"),
              IsEqual(Is32Bit() ? "0x00000005" : "0x0000000000000005"));
  EXPECT_THAT(Eval("(int*)5 - enum_one_ref"),
              IsEqual(Is32Bit() ? "0x00000001" : "0x0000000000000001"));

  EXPECT_THAT(Eval("(long long)UnscopedEnum::kTwo"), IsEqual("2"));
  EXPECT_THAT(Eval("(unsigned int)enum_one"), IsEqual("1"));
  EXPECT_THAT(Eval("(short*)UnscopedEnumUInt8::kTwoU8"),
              IsEqual(Is32Bit() ? "0x00000002" : "0x0000000000000002"));
  EXPECT_THAT(Eval("(float)UnscopedEnum::kOne"), IsEqual("1"));
  EXPECT_THAT(Eval("(float)enum_two"), IsEqual("2"));
  EXPECT_THAT(Eval("(double)enum_one"), IsEqual("1"));
  EXPECT_THAT(Eval("(bool)enum_two"), IsEqual("true"));
  EXPECT_THAT(Eval("(bool)(UnscopedEnum)0"), IsEqual("false"));
  EXPECT_THAT(Eval("(bool)(UnscopedEnum)-1"), IsEqual("true"));
}

TEST_F(EvalTest, TestUnscopedEnumNegation) {
  // Sometimes LLDB is confused about signedness and uses "unsigned int" as an
  // underlying type. Technically, underlying type for the unscoped enum is
  // implementation defined, but it should convert to "int" nonetheless.
  this->compare_with_lldb_ = false;

  bool compare_types = HAS_METHOD(lldb::SBType, GetEnumerationIntegerType());
  EXPECT_THAT(Eval("-enum_one"), XFail(IsEqual("-1", compare_types)));
  EXPECT_THAT(Eval("-enum_one_ref"), XFail(IsEqual("-1", compare_types)));
  EXPECT_THAT(Eval("-(UnscopedEnumEmpty)1"), IsOk(compare_types));
}

TEST_F(EvalTest, TestUnscopedEnumWithUnderlyingType) {
  EXPECT_THAT(Eval("(UnscopedEnumUInt8)-1"), IsOk());
  EXPECT_THAT(Eval("(UnscopedEnumUInt8)256"), IsEqual("kZeroU8"));
  EXPECT_THAT(Eval("(UnscopedEnumUInt8)257"), IsEqual("kOneU8"));

  EXPECT_THAT(Eval("(UnscopedEnumInt8)-2.1"), XFail(IsOk()));
  EXPECT_THAT(Eval("(int)enum_neg_8"), IsEqual("-1"));
  EXPECT_THAT(Eval("enum_neg_8 < enum_one_8"), IsEqual("true"));
  EXPECT_THAT(Eval("enum_neg_8 > enum_one_8"), IsEqual("false"));
}

TEST_F(EvalTest, TestUnscopedEnumEmpty) {
  EXPECT_THAT(Eval("(UnscopedEnumEmpty)1"), IsOk());
  EXPECT_THAT(Eval("(int)enum_empty"), IsOk());
}

TEST_F(EvalTest, TestTernaryOperator) {
  EXPECT_THAT(Eval("true ? c : c"), IsEqual("'\\x02'"));
  EXPECT_THAT(Eval("true ? c : (char)1"), IsEqual("'\\x02'"));
  EXPECT_THAT(Eval("true ? c : 1"), IsEqual("2"));
  EXPECT_THAT(Eval("false ? 1 : c"), IsEqual("2"));

  bool compare_types = HAS_METHOD(lldb::SBType, GetEnumerationIntegerType());
  EXPECT_THAT(Eval("false ? a_enum : EnumA::kOneA"), IsEqual("kOneA"));
  EXPECT_THAT(Eval("false ? b_enum : a_enum"), IsEqual("2", compare_types));
  EXPECT_THAT(Eval("false ? c : b_enum"), IsEqual("1", compare_types));
  EXPECT_THAT(Eval("false ? b_enum : c"), IsEqual("2", compare_types));

  EXPECT_THAT(Eval("true ? (int*)15 : 0"),
              IsEqual(Is32Bit() ? "0x0000000f" : "0x000000000000000f"));
  EXPECT_THAT(Eval("true ? 0 : (int*)15"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("true ? (int*)15 : nullptr"),
              IsEqual(Is32Bit() ? "0x0000000f" : "0x000000000000000f"));
  EXPECT_THAT(Eval("true ? nullptr : (int*)15"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  EXPECT_THAT(Eval("true ? nullptr : 0"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  EXPECT_THAT(Eval("+(true ? arr2 : arr2)"), IsOk());
  EXPECT_THAT(Eval("true ? arr2 : arr3"), IsOk());
  EXPECT_THAT(Eval("true ? arr2 : 0"), IsOk());
  EXPECT_THAT(Eval("true ? 0 : arr2"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("true ? arr2 : nullptr"), IsOk());
  EXPECT_THAT(Eval("true ? nullptr : arr2"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("true ? arr2 : (int*)15"), IsOk());
  EXPECT_THAT(Eval("true ? (int*)15 : arr2"),
              IsEqual(Is32Bit() ? "0x0000000f" : "0x000000000000000f"));

  EXPECT_THAT(Eval("&(true ? arr2 : arr2)"), IsOk());

  EXPECT_THAT(Eval("true ? t : 1"),
              IsError("incompatible operand types ('T' and 'int')\n"
                      "true ? t : 1\n"
                      "     ^"));
  EXPECT_THAT(Eval("true ? 1 : t"),
              IsError("incompatible operand types ('int' and 'T')\n"
                      "true ? 1 : t\n"
                      "     ^"));
  EXPECT_THAT(Eval("true ? (int*)15 : 1"),
              IsError("incompatible operand types ('int *' and 'int')\n"
                      "true ? (int*)15 : 1\n"
                      "     ^"));
  EXPECT_THAT(Eval("true ? arr2 : dbl_arr"),
              IsError("incompatible operand types ('int *' and 'double *')\n"
                      "true ? arr2 : dbl_arr\n"
                      "     ^"));

  EXPECT_THAT(Eval("&(true ? *pi : 0)"),
              IsError("cannot take the address of an rvalue of type 'int'\n"
                      "&(true ? *pi : 0)\n"
                      "^"));
  EXPECT_THAT(Eval("&(true ? arr2 : pi)"),
              IsError("cannot take the address of an rvalue of type 'int *'\n"
                      "&(true ? arr2 : pi)\n"
                      "^"));
  EXPECT_THAT(Eval("&(true ? arr2 : arr3)"),
              IsError("cannot take the address of an rvalue of type 'int *'\n"
                      "&(true ? arr2 : arr3)\n"
                      "^"));

  EXPECT_THAT(Eval("true ? nullptr : pi"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("true ? pi : nullptr"), IsOk());
  EXPECT_THAT(Eval("false ? nullptr : pi"), IsOk());
  EXPECT_THAT(Eval("false ? pi : nullptr"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  // Use pointers and arrays in bool context.
  EXPECT_THAT(Eval("pi ? 1 : 2"), IsEqual("1"));
  EXPECT_THAT(Eval("arr2 ? 1 : 2"), IsEqual("1"));

  GTEST_SKIP() << "Segfault when retrieving result value in the matcher";
  EXPECT_THAT(Eval("true ? 0 : nullptr"),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(Eval("nullptr ? 1 : 2"), IsEqual("2"));
}

TEST_F(EvalTest, TestSizeOf) {
  EXPECT_THAT(Eval("sizeof(int)"), IsEqual("4"));
  EXPECT_THAT(Eval("sizeof(int&)"), IsEqual("4"));
  EXPECT_THAT(Eval("sizeof(int*)"), IsEqual(Is32Bit() ? "4" : "8"));
  EXPECT_THAT(Eval("sizeof(int***)"), IsEqual(Is32Bit() ? "4" : "8"));

  EXPECT_THAT(Eval("sizeof(i)"), IsEqual("4"));
  EXPECT_THAT(Eval("sizeof i "), IsEqual("4"));
  EXPECT_THAT(Eval("sizeof p "), IsEqual(Is32Bit() ? "4" : "8"));
  EXPECT_THAT(Eval("sizeof(arr)"), IsEqual("12"));
  EXPECT_THAT(Eval("sizeof arr "), IsEqual("12"));
  EXPECT_THAT(Eval("sizeof(arr + 1)"), IsEqual(Is32Bit() ? "4" : "8"));
  EXPECT_THAT(Eval("sizeof arr + 1 "), IsEqual("13"));

  EXPECT_THAT(Eval("sizeof(foo)"), IsEqual("8"));
  EXPECT_THAT(Eval("sizeof foo "), IsEqual("8"));
  EXPECT_THAT(Eval("sizeof(SizeOfFoo)"), IsEqual("8"));

  // Makes sure that the expression isn't parsed as two types `i<i>` and `i`.
  EXPECT_THAT(Eval("sizeof(i < i > i)"), IsEqual("1"));

  EXPECT_THAT(
      Eval("sizeof(int & *)"),
      IsError(
          "'type name' declared as a pointer to a reference of type 'int &'\n"
          "sizeof(int & *)\n"
          "             ^"));

  EXPECT_THAT(Eval("sizeof(intt + 1)"),
              IsError("use of undeclared identifier 'intt'\n"
                      "sizeof(intt + 1)\n"
                      "       ^"));
}

TEST_F(EvalTest, TestBuiltinFunction_Log2) {
  // LLDB doesn't support `__log2` intrinsic function.
  this->compare_with_lldb_ = false;

  // Note: Visual Studio debugger gives an error in this case:
  //
  //   > __log(0)
  //   Attempt to calculate __log2(0).
  //
  EXPECT_THAT(Eval("__log2(0)"), IsEqual("4294967295"));
  EXPECT_THAT(Eval("__log2(1LL << 32)"), IsEqual("4294967295"));

  EXPECT_THAT(Eval("__log2(1)"), IsEqual("0"));
  EXPECT_THAT(Eval("__log2(8)"), IsEqual("3"));
  EXPECT_THAT(Eval("__log2(12345)"), IsEqual("13"));
  EXPECT_THAT(Eval("__log2(-1)"), IsEqual("31"));
  EXPECT_THAT(Eval("__log2((1LL << 32)+128)"), IsEqual("7"));

  EXPECT_THAT(Eval("__log2(32.3f)"), IsEqual("5"));
  EXPECT_THAT(Eval("__log2(12345.12345)"), IsEqual("13"));

  EXPECT_THAT(Eval("__log2(c_enum)"), IsEqual("7"));
  EXPECT_THAT(Eval("__log2(cxx_enum)"), IsEqual("7"));
  EXPECT_THAT(Eval("__log2(c_enum_ref)"), IsEqual("7"));
  EXPECT_THAT(Eval("__log2(cxx_enum_ref)"), IsEqual("7"));
  EXPECT_THAT(Eval("__log2(CEnum::kFoo)"), IsEqual("7"));
  EXPECT_THAT(Eval("__log2(CxxEnum::kFoo)"), IsEqual("7"));

  EXPECT_THAT(Eval("__log2(foo)"),
              IsError("no known conversion from 'Foo' to 'unsigned int'\n"
                      "__log2(foo)\n"
                      "       ^"));

  EXPECT_THAT(Eval("__log2()"),
              IsError("no matching function for call to '__log2': requires 1 "
                      "argument(s), but 0 argument(s) were provided\n"
                      "__log2()\n"
                      "^"));

  EXPECT_THAT(Eval("1 + __log2(1, 2)"),
              IsError("no matching function for call to '__log2': requires 1 "
                      "argument(s), but 2 argument(s) were provided\n"
                      "1 + __log2(1, 2)\n"
                      "    ^"));

  EXPECT_THAT(Eval("dummy(1)"),
              IsError("function 'dummy' is not a supported builtin intrinsic"));
  EXPECT_THAT(
      Eval("::dummy(1)"),
      IsError("function '::dummy' is not a supported builtin intrinsic"));
  EXPECT_THAT(
      Eval("ns::dummy(1)"),
      IsError("function 'ns::dummy' is not a supported builtin intrinsic"));
  EXPECT_THAT(
      Eval("::ns::dummy(1)"),
      IsError("function '::ns::dummy' is not a supported builtin intrinsic"));
}

TEST_F(EvalTest, DISABLED_TestPrefixIncDec) {
  EXPECT_THAT(Eval("++1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("--i"),
              IsError("side effects are not supported in this context"));

#ifndef __EMSCRIPTEN__
  ASSERT_TRUE(CreateContextVariableArray("int", "$arr", "{1,2,3}"));
  EXPECT_THAT(EvalWithContext("++$arr", vars_),
              IsError("cannot increment value of type 'int[3]'"));

  ASSERT_TRUE(CreateContextVariable("$enum_foo", "ScopedEnum::kFoo"));
  EXPECT_THAT(EvalWithContext("++$enum_foo", vars_),
              IsError("cannot increment expression of enum type 'ScopedEnum'"));

  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("++$i", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("++$i + 1", vars_), IsEqual("4"));
  EXPECT_THAT(EvalWithContext("--$i", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("--$i - 1", vars_), IsEqual("0"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("++$f", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("++$f + 1", vars_), IsEqual("4.5"));
  EXPECT_THAT(EvalWithContext("--$f", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("--$f - 1", vars_), IsEqual("0.5"));

  ASSERT_TRUE(CreateContextVariable("$d", "1.5"));
  EXPECT_THAT(EvalWithContext("++$d", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("++$d + 1", vars_), IsEqual("4.5"));
  EXPECT_THAT(EvalWithContext("--$d", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("--$d - 1", vars_), IsEqual("0.5"));

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)4"));
  EXPECT_THAT(EvalWithContext("++$p", vars_),
              IsEqual(Is32Bit() ? "0x00000008" : "0x0000000000000008"));
  EXPECT_THAT(EvalWithContext("++$p + 1", vars_),
              IsEqual(Is32Bit() ? "0x00000010" : "0x0000000000000010"));
  EXPECT_THAT(EvalWithContext("--$p", vars_),
              IsEqual(Is32Bit() ? "0x00000008" : "0x0000000000000008"));
  EXPECT_THAT(EvalWithContext("--$p - 1", vars_),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
#endif
}

TEST_F(EvalTest, DISABLED_TestPostfixIncDec) {
  EXPECT_THAT(Eval("1++"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i--"),
              IsError("side effects are not supported in this context"));

#ifndef __EMSCRIPTEN__
  ASSERT_TRUE(CreateContextVariableArray("int", "$arr", "{1,2,3}"));
  EXPECT_THAT(EvalWithContext("$arr--", vars_),
              IsError("cannot decrement value of type 'int[3]'"));

  ASSERT_TRUE(CreateContextVariable("$enum_foo", "ScopedEnum::kFoo"));
  EXPECT_THAT(EvalWithContext("$enum_foo++", vars_),
              IsError("cannot increment expression of enum type 'ScopedEnum'"));

  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("$i++", vars_), IsEqual("1"));
  EXPECT_THAT(EvalWithContext("$i", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i++ + 1", vars_), IsEqual("3"));
  EXPECT_THAT(EvalWithContext("$i--", vars_), IsEqual("3"));
  EXPECT_THAT(EvalWithContext("$i-- - 1", vars_), IsEqual("1"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("$f++", vars_), IsEqual("1.5"));
  EXPECT_THAT(EvalWithContext("$f", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("$f++ + 1", vars_), IsEqual("3.5"));
  EXPECT_THAT(EvalWithContext("$f--", vars_), IsEqual("3.5"));
  EXPECT_THAT(EvalWithContext("$f-- - 1", vars_), IsEqual("1.5"));

  ASSERT_TRUE(CreateContextVariable("$d", "1.5"));
  EXPECT_THAT(EvalWithContext("$d++", vars_), IsEqual("1.5"));
  EXPECT_THAT(EvalWithContext("$d++ + 1", vars_), IsEqual("3.5"));
  EXPECT_THAT(EvalWithContext("$d--", vars_), IsEqual("3.5"));
  EXPECT_THAT(EvalWithContext("$d-- - 1", vars_), IsEqual("1.5"));

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)4"));
  EXPECT_THAT(EvalWithContext("$p++", vars_),
              IsEqual(Is32Bit() ? "0x00000004" : "0x0000000000000004"));
  EXPECT_THAT(EvalWithContext("$p++ + 1", vars_),
              IsEqual(Is32Bit() ? "0x0000000c" : "0x000000000000000c"));
  EXPECT_THAT(EvalWithContext("$p--", vars_),
              IsEqual(Is32Bit() ? "0x0000000c" : "0x000000000000000c"));
  EXPECT_THAT(EvalWithContext("$p-- - 1", vars_),
              IsEqual(Is32Bit() ? "0x00000004" : "0x0000000000000004"));
#endif
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, TestDereferencedType) {
  // When dereferencing the value LLDB also removes the typedef and the
  // resulting value has the canonical type. We have to mitigate that, because
  // having the correct type is important for visualization logic.
  //
  // In this example we have:
  //
  //   ```
  //   struct TTuple { ... };
  //   using TPair = TTuple;
  //   const TPair& p_ref = ...;
  //   const TPair* p_ptr = ...;
  //   ```
  //
  // The expression evaluator removes the references from all values and we must
  // verify that the resulting type is correct.

  for (auto &&expr : {"p_ref", "*p_ptr"}) {
    // Directly evaluate the expression and verify the types.
    auto ret = Eval(expr);

    ASSERT_TRUE(ret.lldb_DIL_error.Success());
    ASSERT_TRUE(ret.lldb_value.has_value());

    ASSERT_STREQ(ret.lldb_DIL_value.GetTypeName(), "TPair");
    ASSERT_STREQ(ret.lldb_value.value().GetTypeName(), "TPair");
  }
}
#endif

TEST_F(EvalTest, TestMemberFunctionCall) {
  // LLDB supports function calls, so disable it.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("c.m()"),
              IsError("member function calls are not supported"));
}

TEST_F(EvalTest, DISABLED_TestAssignment) {
  EXPECT_THAT(Eval("1 = 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i = 1"), IsError("side effects are not supported"));

  EXPECT_THAT(Eval("p = 1"),
              IsError("no known conversion from 'int' to 'float *'"));
  EXPECT_THAT(Eval("eOne = 1"),
              IsError("no known conversion from 'int' to 'Enum'"));

#ifndef __EMSCRIPTEN__
  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("$i = 2", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i = -2", vars_), IsEqual("-2"));
  EXPECT_THAT(EvalWithContext("$i", vars_), IsEqual("-2"));
  EXPECT_THAT(EvalWithContext("$i = eOne", vars_), IsEqual("0"));
  EXPECT_THAT(EvalWithContext("$i", vars_), IsEqual("0"));
  EXPECT_THAT(EvalWithContext("$i = eTwo", vars_), IsEqual("1"));
  EXPECT_THAT(EvalWithContext("$i", vars_), IsEqual("1"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("$f = 2.5", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("$f", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("$f = 3.5f", vars_), IsEqual("3.5"));
  EXPECT_THAT(EvalWithContext("$f", vars_), IsEqual("3.5"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s = 100000", vars_), IsEqual("-31072"));
  EXPECT_THAT(EvalWithContext("$s", vars_), IsEqual("-31072"));

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)10"));
  EXPECT_THAT(EvalWithContext("$p = 1", vars_),
              IsError("no known conversion from 'int' to 'int *'"));
  EXPECT_THAT(EvalWithContext("$p = (int*)12", vars_),
              IsEqual(Is32Bit() ? "0x0000000c" : "0x000000000000000c"));
  EXPECT_THAT(EvalWithContext("$p", vars_),
              IsEqual(Is32Bit() ? "0x0000000c" : "0x000000000000000c"));
  EXPECT_THAT(EvalWithContext("$p = 0", vars_),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));
  EXPECT_THAT(EvalWithContext("$p = nullptr", vars_),
              IsEqual(Is32Bit() ? "0x00000000" : "0x0000000000000000"));

  ASSERT_TRUE(CreateContextVariableArray("int", "$arr", "{1, 2}"));
  EXPECT_THAT(EvalWithContext("$p = $arr", vars_), IsOk());

  ASSERT_TRUE(CreateContextVariableArray("float", "$farr", "{1.f, 2.f}"));
  EXPECT_THAT(EvalWithContext("$p = $farr", vars_),
              IsError("no known conversion from 'float[2]' to 'int *'"));
#endif
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentInvalid) {
  EXPECT_THAT(Eval("1 += 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i += 1"), IsError("side effects are not supported"));

  EXPECT_THAT(Eval("1 -= 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i -= 1"), IsError("side effects are not supported"));

  EXPECT_THAT(Eval("1 *= 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i *= 1"), IsError("side effects are not supported"));

  EXPECT_THAT(Eval("1 /= 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i /= 1"), IsError("side effects are not supported"));

  EXPECT_THAT(Eval("1 %= 1"), IsError("expression is not assignable"));
  EXPECT_THAT(Eval("i %= 1"), IsError("side effects are not supported"));
  EXPECT_THAT(
      Eval("f %= 1"),
      IsError("invalid operands to binary expression ('float' and 'int')"));

#ifndef __EMSCRIPTEN__
  ASSERT_TRUE(CreateContextVariable("Enum", "$e", false, "Enum::ONE"));
  EXPECT_THAT(
      EvalWithContext("$e *= 1", vars_),
      // TODO(werat): This should actually be:
      // > assigning to 'Enum' from incompatible type 'int'
      IsError("invalid operands to binary expression ('Enum' and 'int')"));

  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("($i += 1) -= 2", vars_),
              IsError("side effects are not supported in this context"));
#endif
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestCompositeAssignmentAdd) {
  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("$i += 1", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i += 2", vars_), IsEqual("4"));
  EXPECT_THAT(EvalWithContext("$i += -4", vars_), IsEqual("0"));
  EXPECT_THAT(EvalWithContext("$i += eOne", vars_), IsEqual("0"));
  EXPECT_THAT(EvalWithContext("$i += eTwo", vars_), IsEqual("1"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("$f += 1", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("$f += -2", vars_), IsEqual("0.5"));
  EXPECT_THAT(EvalWithContext("$f += 2.5", vars_), IsEqual("3"));
  EXPECT_THAT(EvalWithContext("$f += eTwo", vars_), IsEqual("4"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s += 1000", vars_), IsEqual("1100"));
  EXPECT_THAT(EvalWithContext("$s += 100000", vars_), IsEqual("-29972"));

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)10"));
  EXPECT_THAT(EvalWithContext("$p += 1", vars_),
              IsEqual(Is32Bit() ? "0x0000000e" : "0x000000000000000e"));
  EXPECT_THAT(
      EvalWithContext("$p += 1.5", vars_),
      IsError("invalid operands to binary expression ('int *' and 'double')"));
  EXPECT_THAT(
      EvalWithContext("$p += $p", vars_),
      IsError("invalid operands to binary expression ('int *' and 'int *')"));
  EXPECT_THAT(EvalWithContext("$i += $p", vars_),
              IsError("no known conversion from 'int *' to 'int'"));
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentSub) {
  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("$i -= 1", vars_), IsEqual("0"));
  EXPECT_THAT(EvalWithContext("$i -= 2", vars_), IsEqual("-2"));
  EXPECT_THAT(EvalWithContext("$i -= -4", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i -= eOne", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i -= eTwo", vars_), IsEqual("1"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("$f -= 1", vars_), IsEqual("0.5"));
  EXPECT_THAT(EvalWithContext("$f -= -2", vars_), IsEqual("2.5"));
  EXPECT_THAT(EvalWithContext("$f -= -2.5", vars_), IsEqual("5"));
  EXPECT_THAT(EvalWithContext("$f -= eTwo", vars_), IsEqual("4"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s -= 1000", vars_), IsEqual("-900"));
  EXPECT_THAT(EvalWithContext("$s -= 100000", vars_), IsEqual("30172"));

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)10"));
  EXPECT_THAT(EvalWithContext("$p -= 1", vars_),
              IsEqual(Is32Bit() ? "0x00000006" : "0x0000000000000006"));

#ifdef _WIN32
  // On Windows, 'ptrdiff_t' is 'long long'.
  EXPECT_THAT(EvalWithContext("$p -= $p", vars_),
              IsError("no known conversion from 'long long' to 'int *'"));
#else
  // On Linux, 'ptrdiff_t' is 'long'.
  EXPECT_THAT(EvalWithContext("$p -= $p", vars_),
              IsError("no known conversion from 'long' to 'int *'"));
#endif
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentMul) {
  ASSERT_TRUE(CreateContextVariable("$i", "1"));
  EXPECT_THAT(EvalWithContext("$i *= 1", vars_), IsEqual("1"));
  EXPECT_THAT(EvalWithContext("$i *= 2", vars_), IsEqual("2"));
  EXPECT_THAT(EvalWithContext("$i *= -2.5", vars_), IsEqual("-5"));
  EXPECT_THAT(EvalWithContext("$i *= eTwo", vars_), IsEqual("-5"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(EvalWithContext("$f *= 1", vars_), IsEqual("1.5"));
  EXPECT_THAT(EvalWithContext("$f *= 2", vars_), IsEqual("3"));
  EXPECT_THAT(EvalWithContext("$f *= -2.5", vars_), IsEqual("-7.5"));
  EXPECT_THAT(EvalWithContext("$f *= eTwo", vars_), IsEqual("-7.5"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s *= 1000", vars_), IsEqual("-31072"));
  EXPECT_THAT(EvalWithContext("$s *= -1000", vars_), IsEqual("7936"));
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentDiv) {
  ASSERT_TRUE(CreateContextVariable("$i", "15"));
  EXPECT_THAT(EvalWithContext("$i /= 1", vars_), IsEqual("15"));
  EXPECT_THAT(EvalWithContext("$i /= 2", vars_), IsEqual("7"));
  EXPECT_THAT(EvalWithContext("$i /= -2", vars_), IsEqual("-3"));
  EXPECT_THAT(EvalWithContext("$i /= eTwo", vars_), IsEqual("-3"));

  ASSERT_TRUE(CreateContextVariable("$f", "15.5f"));
  EXPECT_THAT(EvalWithContext("$f /= 1", vars_), IsEqual("15.5"));
  EXPECT_THAT(EvalWithContext("$f /= 2", vars_), IsEqual("7.75"));
  EXPECT_THAT(EvalWithContext("$f /= -2.5", vars_), IsEqual("-3.0999999"));
  EXPECT_THAT(EvalWithContext("$f /= eTwo", vars_), IsEqual("-3.0999999"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s /= 10", vars_), IsEqual("10"));
  EXPECT_THAT(EvalWithContext("$s /= -3", vars_), IsEqual("-3"));
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentRem) {
  ASSERT_TRUE(CreateContextVariable("$i", "15"));
  EXPECT_THAT(EvalWithContext("$i %= 8", vars_), IsEqual("7"));
  EXPECT_THAT(EvalWithContext("$i %= -3", vars_), IsEqual("1"));
  EXPECT_THAT(EvalWithContext("$i %= eTwo", vars_), IsEqual("0"));

  ASSERT_TRUE(CreateContextVariable("$f", "15.5f"));
  EXPECT_THAT(
      EvalWithContext("$f %= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s %= 23", vars_), IsEqual("8"));
}

TEST_F(EvalTest, DISABLED_TestCompositeAssignmentBitwise) {
  ASSERT_TRUE(CreateContextVariable("$i", "0b11111111"));
  EXPECT_THAT(EvalWithContext("$i &= 0b11110000", vars_), IsEqual("240"));
  EXPECT_THAT(EvalWithContext("$i |= 0b01100011", vars_), IsEqual("243"));
  EXPECT_THAT(EvalWithContext("$i ^= 0b00100010", vars_), IsEqual("209"));
  EXPECT_THAT(EvalWithContext("$i <<= 2", vars_), IsEqual("836"));
  EXPECT_THAT(EvalWithContext("$i >>= 3", vars_), IsEqual("104"));
  EXPECT_THAT(EvalWithContext("$i <<= eTwo", vars_), IsEqual("208"));
  EXPECT_THAT(EvalWithContext("$i >>= eTwo", vars_), IsEqual("104"));
  EXPECT_THAT(EvalWithContext("$i <<= 1U", vars_), IsEqual("208"));
  EXPECT_THAT(EvalWithContext("$i >>= 1LL", vars_), IsEqual("104"));

  ASSERT_TRUE(CreateContextVariable("$c", "(signed char)-1"));
  EXPECT_THAT(EvalWithContext("$c &= 0b11110011", vars_), IsEqual("'\\xf3'"));
  EXPECT_THAT(EvalWithContext("$c |= 0b01001011", vars_), IsEqual("'\\xfb'"));
  EXPECT_THAT(EvalWithContext("$c ^= 0b00000110", vars_), IsEqual("'\\xfd'"));
  EXPECT_THAT(EvalWithContext("$c <<= 5", vars_), IsEqual("'\\xa0'"));
  EXPECT_THAT(EvalWithContext("$c >>= 20", vars_), IsEqual("'\\xff'"));
  EXPECT_THAT(EvalWithContext("$c <<= 2U", vars_), IsEqual("'\\xfc'"));
  EXPECT_THAT(EvalWithContext("$c >>= eTwo", vars_), IsEqual("'\\xfe'"));

  ASSERT_TRUE(CreateContextVariable("$f", "1.5f"));
  EXPECT_THAT(
      EvalWithContext("$f &= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$f |= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$f ^= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$f <<= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$f >>= 1", vars_),
      IsError("invalid operands to binary expression ('float' and 'int')"));

  ASSERT_TRUE(CreateContextVariable("$s", "(short)100"));
  EXPECT_THAT(EvalWithContext("$s >>= 2", vars_), IsEqual("25"));
  EXPECT_THAT(EvalWithContext("$s <<= 6", vars_), IsEqual("1600"));
  EXPECT_THAT(EvalWithContext("$s <<= 12", vars_), IsEqual("0"));

  ASSERT_TRUE(CreateContextVariable("$e", "eTwo"));
  std::vector<std::string> ops = {"&=", "|=", "^=", "<<=", ">>="};
  for (const auto &op : ops) {
    const std::string expr = "$e " + op + " 1"; // e.g. "$e ^= 1"
    EXPECT_THAT(
        EvalWithContext(expr, vars_),
        IsError("invalid operands to binary expression ('Enum' and 'int')"));
  }

  ASSERT_TRUE(CreateContextVariable("$p", "(int*)10"));
  EXPECT_THAT(
      EvalWithContext("$p &= 1", vars_),
      IsError("invalid operands to binary expression ('int *' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$p |= (char)1", vars_),
      IsError("invalid operands to binary expression ('int *' and 'char')"));
  EXPECT_THAT(
      EvalWithContext("$p ^= &f", vars_),
      IsError("invalid operands to binary expression ('int *' and 'float *')"));
  EXPECT_THAT(
      EvalWithContext("$p <<= 1", vars_),
      IsError("invalid operands to binary expression ('int *' and 'int')"));
  EXPECT_THAT(
      EvalWithContext("$p >>= $p", vars_),
      IsError("invalid operands to binary expression ('int *' and 'int *')"));
}

TEST_F(EvalTest, DISABLED_TestSideEffects) {
  // Comparing with LLDB is not possible with side effects enabled -- results
  // will always be different (because the same expression is evaluated twice).
  this->compare_with_lldb_ = false;
  this->allow_side_effects_ = true;

  EXPECT_THAT(Eval("x++"), IsEqual("1"));
  EXPECT_THAT(Eval("x"), IsEqual("2"));
  EXPECT_THAT(Eval("++x"), IsEqual("3"));

  EXPECT_THAT(Eval("xa[0] = 4"), IsEqual("4"));
  EXPECT_THAT(Eval("xa[0]"), IsEqual("4"));
  EXPECT_THAT(Eval("xa[1] += xa[0]"), IsEqual("6"));

  EXPECT_THAT(Eval("*p = 5.2"), IsEqual("5"));
  EXPECT_THAT(Eval("*p"), IsEqual("5"));
  EXPECT_THAT(Eval("x"), IsEqual("5")); // `p` is `&x`
}
#endif

TEST_F(EvalTest, TestBuiltinFunction_findnonnull) {
  // LLDB doesn't support `__findnonnull` intrinsic function.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("__findnonnull(array_of_pointers, 0)"), IsEqual("-1"));
  EXPECT_THAT(Eval("__findnonnull(array_of_pointers, 1)"), IsEqual("0"));
  EXPECT_THAT(Eval("__findnonnull(array_of_pointers, 5)"), IsEqual("0"));
  EXPECT_THAT(Eval("__findnonnull(array_of_pointers+2, 3)"), IsEqual("2"));
  EXPECT_THAT(Eval("__findnonnull(array_of_pointers+3, 2)"), IsEqual("1"));

  EXPECT_THAT(Eval("__findnonnull(pointer_to_pointers, 0)"), IsEqual("-1"));
  EXPECT_THAT(Eval("__findnonnull(pointer_to_pointers, 1)"), IsEqual("0"));
  EXPECT_THAT(Eval("__findnonnull(pointer_to_pointers, 5)"), IsEqual("0"));
  EXPECT_THAT(Eval("__findnonnull(pointer_to_pointers+2, 3)"), IsEqual("2"));
  EXPECT_THAT(Eval("__findnonnull(pointer_to_pointers+3, 2)"), IsEqual("1"));

  EXPECT_THAT(Eval("__findnonnull(0, 0)"),
              IsError("no known conversion from 'int' to 'T*' for 1st argument "
                      "of __findnonnull()\n"
                      "__findnonnull(0, 0)\n"
                      "              ^"));
  EXPECT_THAT(
      Eval("__findnonnull(1.0f, 0)"),
      IsError("no known conversion from 'float' to 'T*' for 1st argument "
              "of __findnonnull()\n"
              "__findnonnull(1.0f, 0)\n"
              "              ^"));
  EXPECT_THAT(
      Eval("__findnonnull(array_of_pointers, -1)"),
      IsError("passing in a buffer size ('-1') that is negative or in excess "
              "of 100 million to __findnonnull() is not allowed.\n"
              "__findnonnull(array_of_pointers, -1)\n"
              "                                 ^"));
  EXPECT_THAT(
      Eval("__findnonnull(array_of_pointers, 100000001)"),
      IsError("passing in a buffer size ('100000001') that is negative "
              "or in excess of 100 million to __findnonnull() is not allowed.\n"
              "__findnonnull(array_of_pointers, 100000001)\n"
              "                                 ^"));

  if (process_.GetAddressByteSize() == 4) {
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8, 6)"), IsEqual("0"));
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8+4, 5)"), IsEqual("0"));
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8+8, 4)"), IsEqual("2"));
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8+12, 3)"), IsEqual("1"));
  } else if (process_.GetAddressByteSize() == 8) {
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8, 3)"), IsEqual("0"));
    EXPECT_THAT(Eval("__findnonnull(array_of_uint8+8, 2)"), IsEqual("1"));
  } else {
    GTEST_FATAL_FAILURE_("Unknown pointer size in the target process");
  }
}

TEST_F(EvalTest, TestUniquePtr) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::unique_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.

  EXPECT_THAT(Eval("*(NodeU**)&ptr_node.__ptr_"), IsOk());
  EXPECT_THAT(Eval("(*(NodeU**)&ptr_node.__ptr_)->value"), IsEqual("1"));

  EXPECT_THAT(Eval("ptr_node.__ptr_"), IsOk());
  EXPECT_THAT(Eval("ptr_node.__ptr_->value"), IsEqual("1"));
  EXPECT_THAT(Eval("ptr_node.__ptr_->next.__ptr_->value"), IsEqual("2"));
#endif
}

TEST_F(EvalTest, TestUniquePtrDeref) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::unique_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.
  this->compare_with_lldb_ = false;

  // Test member-of dereference.
  EXPECT_THAT(Eval("ptr_node->value"), IsEqual("1"));
  EXPECT_THAT(Eval("ptr_node->next->value"), IsEqual("2"));

  // Test ptr dereference.
  EXPECT_THAT(Eval("(*ptr_node).value"), IsEqual("1"));
  EXPECT_THAT(Eval("(*(*ptr_node).next).value"), IsEqual("2"));
#endif
}

TEST_F(EvalTest, TestUniquePtrCompare) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::unique_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("ptr_int == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_int == ptr_int"), XFail(IsEqual("true")));

  // C++ doesn't allow comparing unique_ptr with raw pointers, but we allow it
  // for convenience.
  EXPECT_THAT(Eval("ptr_int == 0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int == (int*)0"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_float == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_float != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_float == (float*)0"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_float == (int*)0"),
              XFail(IsError("comparison of distinct pointer types")));
  EXPECT_THAT(Eval("ptr_int == ptr_float"),
              XFail(IsError("comparison of distinct pointer types")));

  EXPECT_THAT(Eval("ptr_null == nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_null != nullptr"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_void == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_void != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_void == ptr_void"), XFail(IsEqual("true")));

  // Void pointer can be compared with everything.
  EXPECT_THAT(Eval("ptr_void == (int*)0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_void == (void*)0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int == ptr_void"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_float == ptr_void"), XFail(IsEqual("false")));

#endif
}

TEST_F(EvalTest, TestSharedPtr) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::unique_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.

  EXPECT_THAT(Eval("*(NodeS**)&ptr_node.__ptr_"), IsOk());
  EXPECT_THAT(Eval("(*(NodeS**)&ptr_node.__ptr_)->value"), IsEqual("1"));

  EXPECT_THAT(Eval("ptr_node.__ptr_"), IsOk());
  EXPECT_THAT(Eval("ptr_node.__ptr_->value"), IsEqual("1"));
  EXPECT_THAT(Eval("ptr_node.__ptr_->next.__ptr_->value"), IsEqual("2"));

  EXPECT_THAT(Eval("ptr_int.__ptr_"), IsOk());
  EXPECT_THAT(Eval("*ptr_int.__ptr_"), IsEqual("1"));
  EXPECT_THAT(Eval("ptr_int_weak.__ptr_"), IsOk());
  EXPECT_THAT(Eval("*ptr_int_weak.__ptr_"), IsEqual("1"));
#endif
}

TEST_F(EvalTest, TestSharedPtrDeref) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::shared_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.
  this->compare_with_lldb_ = false;

  // Test member-of dereference.
  EXPECT_THAT(Eval("ptr_node->value"), IsEqual("1"));
  EXPECT_THAT(Eval("ptr_node->next->value"), IsEqual("2"));

  // Test ptr dereference.
  EXPECT_THAT(Eval("(*ptr_node).value"), IsEqual("1"));
  EXPECT_THAT(Eval("(*(*ptr_node).next).value"), IsEqual("2"));
#endif
}

TEST_F(EvalTest, TestSharedPtrCompare) {
#ifdef _WIN32
  // On Windows we're not using `libc++` and therefore the layout of
  // `std::shared_ptr` is different.
  GTEST_SKIP() << "not supported on Windows";
#else
  // On Linux this assumes the usage of libc++ standard library.
  this->compare_with_lldb_ = false;

  EXPECT_THAT(Eval("ptr_int == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_int == ptr_int"), XFail(IsEqual("true")));

  // C++ doesn't allow comparing shared_ptr with raw pointers, but we allow it
  // for convenience.
  EXPECT_THAT(Eval("ptr_int == 0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int == (int*)0"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_float == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_float != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_float == (float*)0"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_float == (int*)0"),
              XFail(IsError("comparison of distinct pointer types")));
  EXPECT_THAT(Eval("ptr_int == ptr_float"),
              XFail(IsError("comparison of distinct pointer types")));

  EXPECT_THAT(Eval("ptr_null == nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_null != nullptr"), XFail(IsEqual("false")));

  EXPECT_THAT(Eval("ptr_void == nullptr"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_void != nullptr"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_void == ptr_void"), XFail(IsEqual("true")));

  // Void pointer can be compared with everything.
  EXPECT_THAT(Eval("ptr_void == (int*)0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_void == (void*)0"), XFail(IsEqual("false")));
  EXPECT_THAT(Eval("ptr_int == ptr_void"), XFail(IsEqual("true")));
  EXPECT_THAT(Eval("ptr_float == ptr_void"), XFail(IsEqual("false")));
#endif
}

TEST_F(EvalTest, TestTypeComparison) {
  // This test is for border-case situations in the CompareTypes function.

  // Taking an address of ternary expression require operands of the same type.
  EXPECT_THAT(Eval("&(true ? ip : icpc)"), IsOk());
  EXPECT_THAT(Eval("&(true ? mipp : ipp)"),
              XFail(IsOk(/*compare_types*/ false)));
  EXPECT_THAT(Eval("&(true ? ipp : icpcpc)"), IsOk());
  EXPECT_THAT(Eval("&(true ? ipp : mipp)"), XFail(IsOk()));
  EXPECT_THAT(Eval("&(true ? ipp : micpcpc)"), IsOk());
  // TODO: Enable type comparison once the type mismatch is fixed.
  // LLDB results in "int ***", while lldb-eval results in "MyInt ***".
  EXPECT_THAT(Eval("&(true ? mipp : icpcpc)"),
              XFail(IsOk(/*compare_types*/ false)));
  EXPECT_THAT(Eval("&(true ? mipp : micpcpc)"),
              XFail(IsOk(/*compare_types*/ false)));
  EXPECT_THAT(Eval("&(true ? icpcpc : micpcpc)"), IsOk());

  // Ensure that "signed char" and "char" are different types.
  EXPECT_THAT(Eval("true ? c : sc"), IsEqual("2")); // int
  EXPECT_THAT(Eval("true ? sc : (signed char)67"), IsEqual("'A'"));
  EXPECT_THAT(Eval("true ? (char)66 : (signed char)65"), IsEqual("66"));
  EXPECT_THAT(Eval("true ? cc : mc"), XFail(IsEqual("'B'")));
  EXPECT_THAT(Eval("true ? cc : sc"), IsEqual("66"));
  EXPECT_THAT(Eval("true ? sc : mc"), IsEqual("65"));
  EXPECT_THAT(Eval("&(true ? c : c)"), IsOk());
  EXPECT_THAT(Eval("&(true ? c : sc)"),
              IsError("cannot take the address of an rvalue of type 'int'"));
}

TEST_F(EvalTest, TestTypeVsIdentifier) {
  EXPECT_THAT(Eval("(StructOrVar)+1"), IsEqual("3"));
  EXPECT_THAT(Eval("(StructOrVar)1"),
              IsError("expected 'eof', got: <'1' (numeric_constant)>"));
  EXPECT_THAT(Eval("(ClassOrVar.x - 1)"), IsEqual("2"));
  EXPECT_THAT(Eval("(ClassOrVar).x - 1"), IsEqual("2"));
  EXPECT_THAT(
      Eval("(ClassOrVar)+1"),
      IsError(
          "invalid operands to binary expression ('ClassOrVar' and 'int')"));
  EXPECT_THAT(Eval("(UnionOrVar)[1]"), IsEqual("2"));
  EXPECT_THAT(Eval("*(UnionOrVar)"), IsEqual("1"));
  EXPECT_THAT(Eval("(*UnionOrVar)"), IsEqual("1"));

  EXPECT_THAT(Eval("sizeof(StructOrVar)"), IsEqual("2"));

  EXPECT_THAT(Eval("static_cast<OnlyVar>(0)"),
              IsError("unknown type name 'OnlyVar'"));
  EXPECT_THAT(Eval("static_cast<StructOrVar>(0)"),
              IsError("must use 'struct' tag to refer to type 'StructOrVar' in "
                      "this scope"));
  EXPECT_THAT(
      Eval("static_cast<ClassOrVar>(0)"),
      IsError(
          "must use 'class' tag to refer to type 'ClassOrVar' in this scope"));
  EXPECT_THAT(
      Eval("static_cast<UnionOrVar>(0)"),
      IsError(
          "must use 'union' tag to refer to type 'UnionOrVar' in this scope"));
  EXPECT_THAT(
      Eval("static_cast<EnumOrVar>(0)"),
      IsError(
          "must use 'enum' tag to refer to type 'EnumOrVar' in this scope"));
  EXPECT_THAT(
      Eval("static_cast<CxxEnumOrVar>(0)"),
      IsError(
          "must use 'enum' tag to refer to type 'CxxEnumOrVar' in this scope"));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestSeparateParsing) {
  lldb::SBError error;

  auto expr_a = Scope("a").Compile("a_", error);
  ASSERT_TRUE(error.Success());

  auto expr_b = Scope("b").Compile("b_", error);
  ASSERT_TRUE(error.Success());

  auto expr_c = Scope("c").Compile("a_ * b_ * c_", error);
  ASSERT_TRUE(error.Success());

  auto expr_d = Scope("d").Compile("a_ * b_ * c_ * d_", error);
  ASSERT_TRUE(error.Success());

  Scope("c").Compile("this", error);
  ASSERT_TRUE(error.Success());

  EXPECT_THAT(Scope("a").Eval(expr_a), IsEqual("1"));
  EXPECT_THAT(Scope("b").Eval(expr_b), IsEqual("2"));
  EXPECT_THAT(Scope("c").Eval(expr_c), IsEqual("60"));
  EXPECT_THAT(Scope("d").Eval(expr_d), IsEqual("3024"));

  EXPECT_THAT(Scope("c").Eval(expr_a), IsEqual("3"));
  EXPECT_THAT(Scope("c").Eval(expr_b), IsEqual("4"));
  EXPECT_THAT(Scope("d").Eval(expr_a), IsEqual("6"));
  EXPECT_THAT(Scope("d").Eval(expr_b), IsEqual("7"));
  EXPECT_THAT(Scope("d").Eval(expr_c), IsEqual("336"));

  // Expression parsed in derived-type scope, evaluated in base-type scope.
  EXPECT_THAT(
      Scope("c").Eval(expr_d),
      IsError("expression isn't parsed in the context of compatible type"));
}

TEST_F(EvalTest, DISABLED_TestSeparateParsingWithContextVars) {
  ASSERT_TRUE(CreateContextVariable("$x", "1"));
  ASSERT_TRUE(CreateContextVariable("$y", "2.5"));

  std::unordered_map<std::string, lldb::SBType> args = {
      {"$x", vars_["$x"].GetType()}, {"$y", vars_["$y"].GetType()}};

  lldb::SBError error;

  auto expr_c = Scope("c").CompileWithContext("c_ + $x + $y", args, error);
  ASSERT_TRUE(error.Success());

  EXPECT_THAT(Scope("c").EvalWithContext(expr_c, vars_), IsEqual("8.5"));
  EXPECT_THAT(Scope("d").EvalWithContext(expr_c, vars_), IsEqual("11.5"));

  // Parsed context arguments don't match variables' types in evaluation.
  std::unordered_map<std::string, lldb::SBValue> wrong_vars = {
      {"$x", vars_["$y"]}, {"$y", vars_["$x"]}};
  EXPECT_THAT(Scope("c").EvalWithContext(expr_c, wrong_vars),
              IsError("unexpected type of context variable '$x' (expected "
                      "'int', got 'double')"));

  // Context variable missing for parsed argument.
  std::unordered_map<std::string, lldb::SBValue> incomplete_vars = {
      {"$x", vars_["$x"]}};
  EXPECT_THAT(Scope("c").EvalWithContext(expr_c, incomplete_vars),
              IsError("use of undeclared identifier '$y'"));
}

TEST_F(EvalTest, DISABLED_TestRegisters) {
  // LLDB loses the value formatter when evaluating registers and prints their
  // value "as is". In lldb-eval the value formatter is preserved and the
  // register can be "pretty-printed" depending on its type (e.g. vector
  // registers are printed as vectors).
  // Add an explicit cast so that the values are the same and can be compared.
  EXPECT_THAT(Eval("(uint64_t) $rax"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rbx"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rcx"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rdx"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rdi"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rsi"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rbp"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $rsp"), IsOk());
  EXPECT_THAT(Eval("(uint64_t) $flags"), IsOk());
}

TEST_F(EvalTest, TestRegistersNoDollar) {
  this->compare_with_lldb_ = false;

  // lldb-eval also supports accessing registers without `$`. Any other
  // identifier (e.g. local variable) will shadow the register.

  // Shadowed by a local variable.
  EXPECT_THAT(Eval("rax"), IsEqual("42"));
  // Shadowed by a member field.
  EXPECT_THAT(Eval("rbx"), IsEqual("42"));
  // Shadowed by a global field.
  EXPECT_THAT(Eval("rcx"), IsEqual("42"));

  // Not shadowed by anything.
  for (std::string reg_name : {"rdx", "rdi", "rsi", "rbp", "rsp", "flags"}) {
    lldb::SBValue reg = frame_.FindRegister(reg_name.c_str());
    EXPECT_THAT(Eval(reg_name), IsEqual(reg.GetValue()));
  }
}
#endif

TEST_F(EvalTest, DISABLED_TestCharParsing) {
  EXPECT_THAT(Eval("1 + 'A'"), IsEqual("66"));
  EXPECT_THAT(Eval("'B' - 'A'"), IsEqual("1"));
  EXPECT_THAT(Eval("'A' == 'B'"), IsEqual("false"));
  EXPECT_THAT(Eval("'A' == 'A'"), IsEqual("true"));

  // Following test fails detecting different results from lldb
  // as u8 prefix is not handled in lldb
  // EXPECT_THAT(Eval("1 + u8'A'"), IsEqual("66"));
  // EXPECT_THAT(Eval("u8'B' - u8'A'"), IsEqual("1"));
  // EXPECT_THAT(Eval("u8'A' == u8'B'"), IsEqual("false"));
  // EXPECT_THAT(Eval("u8'A' == u8'A'"), IsEqual("true"));

  EXPECT_THAT(Eval("1 + u'A'"), IsEqual("66"));
  EXPECT_THAT(Eval("u'B' - u'A'"), IsEqual("1"));
  EXPECT_THAT(Eval("u'A' == u'B'"), IsEqual("false"));
  EXPECT_THAT(Eval("u'A' == u'A'"), IsEqual("true"));

  EXPECT_THAT(Eval("1 + U'A'"), IsEqual("66"));
  EXPECT_THAT(Eval("U'B' - U'A'"), IsEqual("1"));
  EXPECT_THAT(Eval("U'A' == U'B'"), IsEqual("false"));
  EXPECT_THAT(Eval("U'A' == U'A'"), IsEqual("true"));

  EXPECT_THAT(Eval("1 + L'A'"), IsEqual("66"));
  EXPECT_THAT(Eval("L'B' - L'A'"), IsEqual("1"));
  EXPECT_THAT(Eval("L'A' == L'B'"), IsEqual("false"));
  EXPECT_THAT(Eval("L'A' == L'A'"), IsEqual("true"));

  EXPECT_THAT(Eval("1 + 'ABC'"), IsEqual("4276804"));
  EXPECT_THAT(Eval("'ABD' - 'ABC'"), IsEqual("1"));
  EXPECT_THAT(Eval("'ABC' == 'BCD'"), IsEqual("false"));
  EXPECT_THAT(Eval("'ABC' == 'ABC'"), IsEqual("true"));

  EXPECT_THAT(Eval("U'ъ' == U'猫'"), IsEqual("false"));
  EXPECT_THAT(Eval("U'ü' == U'ü'"), IsEqual("true"));
  EXPECT_THAT(Eval("U'u' == U'ü'"), IsEqual("false"));

  // Multichar contants with more than 4 chars generate
  // compiler warning in clang
  // Only the rightmost 4 characters are considered
  // to compute the constant's value
  EXPECT_THAT(Eval("'Xabcd' == 'Yabcd'"), IsEqual("true"));
  EXPECT_THAT(Eval("'abcdX' == 'abcdY'"), IsEqual("false"));
}

#ifndef __EMSCRIPTEN__
TEST_F(EvalTest, DISABLED_TestStringParsing) {
  lldb::SBError ignore;
  // Comparing is done manually (instead of using IsOk and IsEqual matchers).
  // This is because `SBValue::GetValue()` returns a nullptr for array types.
  {
    auto result = Eval("\"abc\"");
    EXPECT_TRUE(result.lldb_DIL_error.Success());
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    EXPECT_EQ(data.GetByteSize(), (size_t)4);
    EXPECT_STREQ(data.GetString(ignore, 0), "abc");
  }
  {
    auto result = Eval("\"\"");
    EXPECT_TRUE(result.lldb_DIL_error.Success());
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    EXPECT_EQ(data.GetByteSize(), (size_t)1);
    EXPECT_STREQ(data.GetString(ignore, 0), "");
  }
  {
    auto result = Eval("u8\"abc\"");
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    EXPECT_EQ(data.GetByteSize(), (size_t)4);
    EXPECT_STREQ(data.GetString(ignore, 0), "abc");
  }
  {
    auto result = Eval("u\"abc\"");
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    EXPECT_EQ(data.GetByteSize(), (size_t)8);
    char16_t val[4];
    EXPECT_EQ(data.ReadRawData(ignore, 0, reinterpret_cast<void *>(val), 8),
              (size_t)8);
    EXPECT_EQ(val[0], u'a');
    EXPECT_EQ(val[1], u'b');
    EXPECT_EQ(val[2], u'c');
    EXPECT_EQ(val[3], 0);
  }
  {
    auto result = Eval("U\"猫ъü\"");
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    EXPECT_EQ(data.GetByteSize(), (size_t)16);
    char32_t val[4];
    EXPECT_EQ(
        data.ReadRawData(ignore, 0, reinterpret_cast<void *>(val), (size_t)16),
        (size_t)16);
    EXPECT_EQ(val[0], U'猫');
    EXPECT_EQ(val[1], U'ъ');
    EXPECT_EQ(val[2], U'ü');
    EXPECT_EQ(val[3], U'\0');
  }
  {
    auto result = Eval("L\"abc\"");
    EXPECT_TRUE(result.lldb_DIL_value.IsValid());
    auto data = result.lldb_DIL_value.GetData();
    wchar_t val[4];
#ifdef _WIN32
    // On Windows it holds sizeof(wchar_t) == 2.
    EXPECT_EQ(data.GetByteSize(), (size_t)(size_t)8);
    EXPECT_EQ(data.ReadRawData(ignore, 0, reinterpret_cast<void *>(val), 8),
              (size_t)8);
#else
    EXPECT_EQ(data.GetByteSize(), (size_t)16);
    EXPECT_EQ(data.ReadRawData(ignore, 0, reinterpret_cast<void *>(val), 16),
              (size_t)16);
#endif
    EXPECT_EQ(val[0], L'a');
    EXPECT_EQ(val[1], L'b');
    EXPECT_EQ(val[2], L'c');
    EXPECT_EQ(val[3], 0);
  }

  // TODO: lldb-eval should be able to handle these cases once string-literals
  // are properly supported.
  EXPECT_THAT(Eval("\"abc\" \"def\""),
              IsError("string literals are not supported"));
  EXPECT_THAT(Eval("\"abc\" + 1"),
              IsError("string literals are not supported"));
  EXPECT_THAT(Eval("*\"abc\""), IsError("string literals are not supported"));
}
#endif