// Copyright 2013 Google LLC
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google LLC nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// stackwalker_address_list_unittest.cc: Unit tests for the
// StackwalkerAddressList class.
//
// Author: Chris Hamilton <chrisha@chromium.org>

#ifdef HAVE_CONFIG_H
#include <config.h>  // Must come first
#endif

#include <string>
#include <vector>

#include "breakpad_googletest_includes.h"
#include "common/using_std_string.h"
#include "google_breakpad/common/minidump_format.h"
#include "google_breakpad/processor/basic_source_line_resolver.h"
#include "google_breakpad/processor/call_stack.h"
#include "google_breakpad/processor/code_module.h"
#include "google_breakpad/processor/source_line_resolver_interface.h"
#include "google_breakpad/processor/stack_frame.h"
#include "processor/stackwalker_unittest_utils.h"
#include "processor/stackwalker_address_list.h"

using google_breakpad::BasicSourceLineResolver;
using google_breakpad::CallStack;
using google_breakpad::CodeModule;
using google_breakpad::StackFrameSymbolizer;
using google_breakpad::StackFrame;
using google_breakpad::Stackwalker;
using google_breakpad::StackwalkerAddressList;
using std::vector;
using testing::_;
using testing::AnyNumber;
using testing::DoAll;
using testing::Return;
using testing::SetArgumentPointee;

#define arraysize(f) (sizeof(f) / sizeof(*f))

// Addresses and sizes of a couple dummy modules.
uint64_t kModule1Base = 0x40000000;
uint64_t kModule1Size = 0x10000;
uint64_t kModule2Base = 0x50000000;
uint64_t kModule2Size = 0x10000;

// A handful of addresses that lie within the modules above.
const uint64_t kDummyFrames[] = {
    0x50003000, 0x50002000, 0x50001000, 0x40002000, 0x40001000 };

class StackwalkerAddressListTest : public testing::Test {
 public:
  StackwalkerAddressListTest()
    : // Give the two modules reasonable standard locations and names
      // for tests to play with.
      module1(kModule1Base, kModule1Size, "module1", "version1"),
      module2(kModule2Base, kModule2Size, "module2", "version2") {
    // Create some modules with some stock debugging information.
    modules.Add(&module1);
    modules.Add(&module2);

    // By default, none of the modules have symbol info; call
    // SetModuleSymbols to override this.
    EXPECT_CALL(supplier, GetCStringSymbolData(_, _, _, _, _))
      .WillRepeatedly(Return(MockSymbolSupplier::NOT_FOUND));

    // Avoid GMOCK WARNING "Uninteresting mock function call - returning
    // directly" for FreeSymbolData().
    EXPECT_CALL(supplier, FreeSymbolData(_)).Times(AnyNumber());
  }

  // Set the Breakpad symbol information that supplier should return for
  // MODULE to INFO.
  void SetModuleSymbols(MockCodeModule* module, const string& info) {
    size_t buffer_size;
    char* buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
    EXPECT_CALL(supplier, GetCStringSymbolData(module, nullptr, _, _, _))
      .WillRepeatedly(DoAll(SetArgumentPointee<3>(buffer),
                            SetArgumentPointee<4>(buffer_size),
                            Return(MockSymbolSupplier::FOUND)));
  }

  void CheckCallStack(const CallStack& call_stack, bool allow_inline=false) {
    const std::vector<StackFrame*>* frames = call_stack.frames();
    ASSERT_LE(arraysize(kDummyFrames), frames->size());

    // Iterate through the produced stack frames, validating that all of the
    // prewalked frames match the expected input frames. Inlined frames are only
    // allowed if `allow_inline` is set to true.

    size_t j = 0;
    for (size_t i = 0; i < frames->size(); ++i) {
      if (j <= 2) {
        ASSERT_EQ(static_cast<const CodeModule*>(&module2), frames->at(i)->module);
      } else {
        ASSERT_EQ(static_cast<const CodeModule*>(&module1), frames->at(i)->module);
      }

      ASSERT_EQ(kDummyFrames[j], frames->at(i)->instruction);
      if (frames->at(i)->trust == StackFrame::FRAME_TRUST_PREWALKED) {
        // Only move on to the next "real" stack frame if this isn't an
        // inlined stack frame.
        ++j;
      } else {
        ASSERT_TRUE(allow_inline);
        ASSERT_EQ(StackFrame::FRAME_TRUST_INLINE, frames->at(i)->trust);
      }
    }
  }

  MockCodeModule module1;
  MockCodeModule module2;
  MockCodeModules modules;
  MockSymbolSupplier supplier;
  BasicSourceLineResolver resolver;
};

TEST_F(StackwalkerAddressListTest, ScanWithoutSymbols) {
  StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
  StackwalkerAddressList walker(kDummyFrames, arraysize(kDummyFrames),
                         &modules, &frame_symbolizer);

  CallStack call_stack;
  vector<const CodeModule*> modules_without_symbols;
  vector<const CodeModule*> modules_with_corrupt_symbols;
  ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                          &modules_with_corrupt_symbols));

  // The stack starts in module2, so we expect that to be the first module
  // found without symbols.
  ASSERT_EQ(2U, modules_without_symbols.size());
  ASSERT_EQ("module2", modules_without_symbols[0]->debug_file());
  ASSERT_EQ("module1", modules_without_symbols[1]->debug_file());
  ASSERT_EQ(0u, modules_with_corrupt_symbols.size());

  ASSERT_NO_FATAL_FAILURE(CheckCallStack(call_stack));
}

TEST_F(StackwalkerAddressListTest, ScanWithSymbols) {
  // File    : FILE number(dex) name
  // Function: FUNC address(hex) size(hex) parameter_size(hex) name
  // Line    : address(hex) size(hex) line(dec) filenum(dec)
  SetModuleSymbols(&module2,
                   "FILE 1 module2.cc\n"
                   "FUNC 3000 100 10 mod2func3\n"
                   "3000 10 1  1\n"
                   "FUNC 2000 200 10 mod2func2\n"
                   "FUNC 1000 300 10 mod2func1\n");
  SetModuleSymbols(&module1,
                   "FUNC 2000 200 10 mod1func2\n"
                   "FUNC 1000 300 10 mod1func1\n");

  StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
  StackwalkerAddressList walker(kDummyFrames, arraysize(kDummyFrames),
                         &modules, &frame_symbolizer);

  CallStack call_stack;
  vector<const CodeModule*> modules_without_symbols;
  vector<const CodeModule*> modules_with_corrupt_symbols;
  ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                          &modules_with_corrupt_symbols));

  ASSERT_EQ(0u, modules_without_symbols.size());
  ASSERT_EQ(0u, modules_with_corrupt_symbols.size());

  ASSERT_NO_FATAL_FAILURE(CheckCallStack(call_stack));

  const std::vector<StackFrame*>* frames = call_stack.frames();

  // We have full file/line information for the first function call.
  ASSERT_EQ("mod2func3", frames->at(0)->function_name);
  ASSERT_EQ(0x50003000u, frames->at(0)->function_base);
  ASSERT_EQ("module2.cc", frames->at(0)->source_file_name);
  ASSERT_EQ(1, frames->at(0)->source_line);
  ASSERT_EQ(0x50003000u, frames->at(0)->source_line_base);

  ASSERT_EQ("mod2func2", frames->at(1)->function_name);
  ASSERT_EQ(0x50002000u, frames->at(1)->function_base);

  ASSERT_EQ("mod2func1", frames->at(2)->function_name);
  ASSERT_EQ(0x50001000u, frames->at(2)->function_base);

  ASSERT_EQ("mod1func2", frames->at(3)->function_name);
  ASSERT_EQ(0x40002000u, frames->at(3)->function_base);

  ASSERT_EQ("mod1func1", frames->at(4)->function_name);
  ASSERT_EQ(0x40001000u, frames->at(4)->function_base);
}

TEST_F(StackwalkerAddressListTest, ScanWithInlining) {
  // File    : FILE number(dex) name
  // Function: FUNC address(hex) size(hex) parameter_size(hex) name
  // Inline: : INLINE_ORIGIN number(dec) name
  //         : INLINE depth(dec) line(dec) filenum(dec) inlinenum(dec)
  //                  address(hex) size(hex)
  // Line    : address(hex) size(hex) line(dec) filenum(dec)
  SetModuleSymbols(&module2,
                   "FILE 1 module2.cc\n"
                   "INLINE_ORIGIN 0 mod2inlinefunc1\n"
                   "INLINE_ORIGIN 1 mod2inlinefunc2\n"
                   "INLINE_ORIGIN 2 mod2inlinefunc3\n"
                   "FUNC 3000 100 10 mod2func3\n"
                   "INLINE 0 1 1 1 3000 10\n"
                   "INLINE 1 1 1 2 3000 10\n"
                   "3000 10 1  1\n"
                   "FUNC 2000 200 10 mod2func2\n"
                   "INLINE 0 1 1 0 2000 10\n"
                   "FUNC 1000 300 10 mod2func1\n");
  SetModuleSymbols(&module1,
                   "FUNC 2000 200 10 mod1func2\n"
                   "FUNC 1000 300 10 mod1func1\n");

  StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
  StackwalkerAddressList walker(kDummyFrames, arraysize(kDummyFrames),
                         &modules, &frame_symbolizer);

  CallStack call_stack;
  vector<const CodeModule*> modules_without_symbols;
  vector<const CodeModule*> modules_with_corrupt_symbols;
  ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                          &modules_with_corrupt_symbols));

  ASSERT_EQ(0u, modules_without_symbols.size());
  ASSERT_EQ(0u, modules_with_corrupt_symbols.size());

  ASSERT_NO_FATAL_FAILURE(CheckCallStack(call_stack, /*allow_inline=*/true));

  const std::vector<StackFrame*>* frames = call_stack.frames();

  // We have full file/line information for the first function call, including
  // inline functions
  ASSERT_EQ("mod2inlinefunc3", frames->at(0)->function_name);
  ASSERT_EQ(0x50003000u, frames->at(0)->function_base);
  ASSERT_EQ("module2.cc", frames->at(0)->source_file_name);
  ASSERT_EQ(1, frames->at(0)->source_line);
  ASSERT_EQ(0x50003000u, frames->at(0)->source_line_base);

  ASSERT_EQ("mod2inlinefunc2", frames->at(1)->function_name);
  ASSERT_EQ(0x50003000u, frames->at(1)->function_base);
  ASSERT_EQ("module2.cc", frames->at(1)->source_file_name);
  ASSERT_EQ(1, frames->at(1)->source_line);
  ASSERT_EQ(0x50003000u, frames->at(1)->source_line_base);

  ASSERT_EQ("mod2func3", frames->at(2)->function_name);
  ASSERT_EQ(0x50003000u, frames->at(2)->function_base);
  ASSERT_EQ("module2.cc", frames->at(2)->source_file_name);
  ASSERT_EQ(1, frames->at(2)->source_line);
  ASSERT_EQ(0x50003000u, frames->at(2)->source_line_base);

  // Here we have inlining information, but no file/line information.
  ASSERT_EQ("mod2inlinefunc1", frames->at(3)->function_name);
  ASSERT_EQ(0x50002000u, frames->at(3)->function_base);

  ASSERT_EQ("mod2func2", frames->at(4)->function_name);
  ASSERT_EQ(0x50002000u, frames->at(4)->function_base);

  ASSERT_EQ("mod2func1", frames->at(5)->function_name);
  ASSERT_EQ(0x50001000u, frames->at(5)->function_base);

  ASSERT_EQ("mod1func2", frames->at(6)->function_name);
  ASSERT_EQ(0x40002000u, frames->at(6)->function_base);

  ASSERT_EQ("mod1func1", frames->at(7)->function_name);
  ASSERT_EQ(0x40001000u, frames->at(7)->function_base);
}
