The Tor Browser: toolkit/crashreporter/google-breakpad/src/common/stabs_reader

toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 // Copyright (c) 2010 Google Inc.
 // All rights reserved.
 //
 // 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 Inc. 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.
 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
 // stabs_reader_unittest.cc: Unit tests for google_breakpad::StabsReader.
 #include <assert.h>
 #include <errno.h>
 #include <stab.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fstream>
 #include <iomanip>
 #include <iostream>
 #include <map>
 #include <sstream>
 #include <string>
 #include "breakpad_googletest_includes.h"
 #include "common/stabs_reader.h"
 #include "common/test_assembler.h"
 #include "common/using_std_string.h"
 using ::testing::Eq;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::StrEq;
 using ::testing::Test;
 using ::testing::_;
 using google_breakpad::StabsHandler;
 using google_breakpad::StabsReader;
 using google_breakpad::test_assembler::Label;
 using google_breakpad::test_assembler::Section;
 using google_breakpad::test_assembler::kBigEndian;
 using google_breakpad::test_assembler::kLittleEndian;
 using std::map;
 namespace {
 // A StringAssembler is a class for generating .stabstr sections to present
 // as input to the STABS parser.
 class StringAssembler: public Section {
  public:
   StringAssembler() : in_cu_(false) { StartCU(); }
   // Add the string S to this StringAssembler, and return the string's
   // offset within this compilation unit's strings. If S has been added
   // already, this returns the offset of its first instance.
   size_t Add(const string &s) {
     map<string, size_t>::iterator it = added_.find(s);
     if (it != added_.end())
       return it->second;
     size_t offset = Size() - cu_start_;
     AppendCString(s);
     added_[s] = offset;
     return offset;
   }
   // Start a fresh compilation unit string collection.
   void StartCU() {
     // Ignore duplicate calls to StartCU. Our test data don't always call
     // StartCU at all, meaning that our constructor has to take care of it,
     // meaning that tests that *do* call StartCU call it twice at the
     // beginning.  This is not worth smoothing out.
     if (in_cu_) return;
     added_.clear();
     cu_start_ = Size();
     // Each compilation unit's strings start with an empty string.
     AppendCString("");
     added_[""] = 0;
     in_cu_ = true;
   }
   // Finish off the current CU's strings.
   size_t EndCU() {
     assert(in_cu_);
     in_cu_ = false;
     return Size() - cu_start_;
   }
  private:
   // The offset of the start of this compilation unit's strings.
   size_t cu_start_;
   // True if we're in a CU.
   bool in_cu_;
   // A map from the strings that have been added to this section to
   // their starting indices within their compilation unit.
   map<string, size_t> added_;
 };
 // A StabsAssembler is a class for generating .stab sections to present as
 // test input for the STABS parser.
 class StabsAssembler: public Section {
  public:
   // Create a StabsAssembler that uses StringAssembler for its strings.
   StabsAssembler(StringAssembler *string_assembler)
       : Section(string_assembler->endianness()),
         string_assembler_(string_assembler),
         value_size_(0),
         entry_count_(0),
         cu_header_(NULL) { }
   ~StabsAssembler() { assert(!cu_header_); }
   // Accessor and setter for value_size_.
   size_t value_size() const { return value_size_; }
   StabsAssembler &set_value_size(size_t value_size) {
     value_size_ = value_size;
     return *this;
   }
   // Append a STAB entry to the end of this section with the given
   // characteristics. NAME is the offset of this entry's name string within
   // its compilation unit's portion of the .stabstr section; this can be a
   // value generated by a StringAssembler. Return a reference to this
   // StabsAssembler.
   StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
                        Label value, Label name) {
     D32(name);
     D8(type);
     D8(other);
     D16(descriptor);
     Append(endianness(), value_size_, value);
     entry_count_++;
     return *this;
   }
   // As above, but automatically add NAME to our StringAssembler.
   StabsAssembler &Stab(uint8_t type, uint8_t other, Label descriptor,
                        Label value, const string &name) {
     return Stab(type, other, descriptor, value, string_assembler_->Add(name));
   }
   // Start a compilation unit named NAME, with an N_UNDF symbol to start
   // it, and its own portion of the string section. Return a reference to
   // this StabsAssembler.
   StabsAssembler &StartCU(const string &name) {
     assert(!cu_header_);
     cu_header_ = new CUHeader;
     string_assembler_->StartCU();
     entry_count_ = 0;
     return Stab(N_UNDF, 0,
                 cu_header_->final_entry_count,
                 cu_header_->final_string_size,
                 string_assembler_->Add(name));
   }
   // Close off the current compilation unit. Return a reference to this
   // StabsAssembler.
   StabsAssembler &EndCU() {
     assert(cu_header_);
     cu_header_->final_entry_count = entry_count_;
     cu_header_->final_string_size = string_assembler_->EndCU();
     delete cu_header_;
     cu_header_ = NULL;
     return *this;
   }
  private:
   // Data used in a compilation unit header STAB that we won't know until
   // we've finished the compilation unit.
   struct CUHeader {
     // The final number of entries this compilation unit will hold.
     Label final_entry_count;
     // The final size of this compilation unit's strings.
     Label final_string_size;
   };
   // The strings for our STABS entries.
   StringAssembler *string_assembler_;
   // The size of the 'value' field of stabs entries in this section.
   size_t value_size_;
   // The number of entries in this compilation unit so far.
   size_t entry_count_;
   // Header labels for this compilation unit, if we've started one but not
   // finished it.
   CUHeader *cu_header_;
 };
 class MockStabsReaderHandler: public StabsHandler {
  public:
   MOCK_METHOD3(StartCompilationUnit,
                bool(const char *, uint64_t, const char *));
   MOCK_METHOD1(EndCompilationUnit, bool(uint64_t));
   MOCK_METHOD2(StartFunction, bool(const string &, uint64_t));
   MOCK_METHOD1(EndFunction, bool(uint64_t));
   MOCK_METHOD3(Line, bool(uint64_t, const char *, int));
   MOCK_METHOD2(Extern, bool(const string &, uint64_t));
   void Warning(const char *format, ...) { MockWarning(format); }
   MOCK_METHOD1(MockWarning, void(const char *));
 };
 struct StabsFixture {
   StabsFixture() : stabs(&strings), unitized(true) { }
   // Create a StabsReader to parse the mock stabs data in stabs and
   // strings, and pass the parsed information to mock_handler. Use the
   // endianness and value size of stabs to parse the data. If all goes
   // well, return the result of calling the reader's Process member
   // function. Otherwise, return false.
   bool ApplyHandlerToMockStabsData() {
     string stabs_contents, stabstr_contents;
     if (!stabs.GetContents(&stabs_contents) ||
         !strings.GetContents(&stabstr_contents))
       return false;
     // Run the parser on the test input, passing whatever we find to HANDLER.
     StabsReader reader(
         reinterpret_cast<const uint8_t *>(stabs_contents.data()),
         stabs_contents.size(),
         reinterpret_cast<const uint8_t *>(stabstr_contents.data()),
         stabstr_contents.size(),
         stabs.endianness() == kBigEndian, stabs.value_size(), unitized,
         &mock_handler);
     return reader.Process();
   }
   StringAssembler strings;
   StabsAssembler stabs;
   bool unitized;
   MockStabsReaderHandler mock_handler;
 };
 class Stabs: public StabsFixture, public Test { };
 TEST_F(Stabs, MockStabsInput) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
   stabs
       .Stab(N_SO,      149, 40232, 0x18a2a72bU, "builddir/")
       .Stab(N_FUN,      83, 50010, 0x91a5353fU,
             "not the SO with source file name we expected ")
       .Stab(N_SO,      165, 24791, 0xfe69d23cU, "")
       .Stab(N_SO,      184, 34178, 0xca4d883aU, "builddir1/")
       .Stab(N_SO,       83, 40859, 0xd2fe5df3U, "file1.c")
       .Stab(N_LSYM,    147, 39565, 0x60d4bb8aU, "not the FUN we're looking for")
       .Stab(N_FUN,     120, 50271, 0xa049f4b1U, "fun1")
       .Stab(N_BINCL,   150, 15694, 0xef65c659U,
             "something to ignore in a FUN body")
       .Stab(N_SLINE,   147,  4967, 0xd904b3f, "")
       .Stab(N_SOL,     177, 56135, 0xbd97b1dcU, "header.h")
       .Stab(N_SLINE,   130, 24610, 0x90f145b, "")
       .Stab(N_FUN,      45, 32441, 0xbf27cf93U,
             "fun2:some stabs type info here:to trim from the name")
       .Stab(N_SLINE,   138, 39002, 0x8148b87, "")
       .Stab(N_SOL,      60, 49318, 0x1d06e025U, "file1.c")
       .Stab(N_SLINE,    29, 52163, 0x6eebbb7, "")
       .Stab(N_SO,      167,  4647, 0xd04b7448U, "")
       .Stab(N_LSYM,     58, 37837, 0xe6b14d37U, "")
       .Stab(N_SO,      152,  7810, 0x11759f10U, "file3.c")
       .Stab(N_SO,      218, 12447, 0x11cfe4b5U, "");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("file1.c"), 0xd2fe5df3U,
                                      StrEq("builddir1/")))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartFunction(StrEq("fun1"), 0xa049f4b1U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0xa049f4b1U + 0xd904b3f, StrEq("file1.c"), 4967))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0xa049f4b1U + 0x90f145b, StrEq("header.h"), 24610))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xbf27cf93U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartFunction(StrEq("fun2"), 0xbf27cf93U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0xbf27cf93U + 0x8148b87, StrEq("header.h"), 39002))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0xbf27cf93U + 0x6eebbb7, StrEq("file1.c"), 52163))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xd04b7448U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0xd04b7448U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartCompilationUnit(StrEq("file3.c"),
 x11759f10U, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0x11cfe4b5U))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, AbruptCU) {
   stabs.set_endianness(kBigEndian);
   stabs.set_value_size(4);
   stabs.Stab(N_SO, 177, 23446, 0xbf10d5e4, "file2-1.c");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("file2-1.c"), 0xbf10d5e4, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, AbruptFunction) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(8);
   stabs
       .Stab(N_SO,      218,   26631,   0xb83ddf10U, "file3-1.c")
       .Stab(N_FUN,     113,   24765,   0xbbd4a145U, "fun3_1");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("file3-1.c"), 0xb83ddf10U, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartFunction(StrEq("fun3_1"), 0xbbd4a145U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, NoCU) {
   stabs.set_endianness(kBigEndian);
   stabs.set_value_size(8);
   stabs.Stab(N_SO, 161, 25673, 0x8f676e7bU, "build-directory/");
   EXPECT_CALL(mock_handler, StartCompilationUnit(_, _, _))
       .Times(0);
   EXPECT_CALL(mock_handler, StartFunction(_, _))
       .Times(0);
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, NoCUEnd) {
   stabs.set_endianness(kBigEndian);
   stabs.set_value_size(8);
   stabs
       .Stab(N_SO,      116,   58280,   0x2f7493c9U, "file5-1.c")
       .Stab(N_SO,      224,   23057,   0xf9f1d50fU, "file5-2.c");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("file5-1.c"), 0x2f7493c9U, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("file5-2.c"), 0xf9f1d50fU, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 // On systems that store STABS in sections, string offsets are relative to
 // the beginning of that compilation unit's strings, marked with N_UNDF
 // symbols; see the comments for StabsReader::StabsReader.
 TEST_F(Stabs, Unitized) {
   stabs.set_endianness(kBigEndian);
   stabs.set_value_size(4);
   stabs
       .StartCU("antimony")
       .Stab(N_SO,   49, 26043, 0x7e259f1aU, "antimony")
       .Stab(N_FUN, 101, 63253, 0x7fbcccaeU, "arsenic")
       .Stab(N_SO,  124, 37175, 0x80b0014cU, "")
       .EndCU()
       .StartCU("aluminum")
       .Stab(N_SO,   72, 23084, 0x86756839U, "aluminum")
       .Stab(N_FUN,  59,  3305, 0xa8e120b0U, "selenium")
       .Stab(N_SO,  178, 56949, 0xbffff983U, "")
       .EndCU();
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("antimony"), 0x7e259f1aU, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartFunction(Eq("arsenic"), 0x7fbcccaeU))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0x80b0014cU))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0x80b0014cU))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("aluminum"), 0x86756839U, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, StartFunction(Eq("selenium"), 0xa8e120b0U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xbffff983U))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0xbffff983U))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 // On systems that store STABS entries in the real symbol table, the N_UNDF
 // entries have no special meaning, and shouldn't mess up the string
 // indices.
 TEST_F(Stabs, NonUnitized) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
   unitized = false;
   stabs
       .Stab(N_UNDF,    21, 11551, 0x9bad2b2e, "")
       .Stab(N_UNDF,    21, 11551, 0x9bad2b2e, "")
       .Stab(N_SO,      71, 45139, 0x11a97352, "Tanzania")
       .Stab(N_SO,     221, 41976, 0x21a97352, "");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("Tanzania"),
 x11a97352, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0x21a97352))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, FunctionEnd) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(8);
   stabs
       .Stab(N_SO,    102, 62362, 0x52a830d644cd6942ULL, "compilation unit")
       // This function is terminated by the start of the next function.
       .Stab(N_FUN,   216, 38405, 0xbb5ab70ecdd23bfeULL, "function 1")
       // This function is terminated by an explicit end-of-function stab,
       // whose value is a size in bytes.
       .Stab(N_FUN,   240, 10973, 0xc954de9b8fb3e5e2ULL, "function 2")
       .Stab(N_FUN,    14, 36749, 0xc1ab,     "")
       // This function is terminated by the end of the compilation unit.
       .Stab(N_FUN,   143, 64514, 0xdff98c9a35386e1fULL, "function 3")
       .Stab(N_SO,    164, 60142, 0xfdacb856e78bbf57ULL, "");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("compilation unit"),
 x52a830d644cd6942ULL, NULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartFunction(Eq("function 1"), 0xbb5ab70ecdd23bfeULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xc954de9b8fb3e5e2ULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartFunction(Eq("function 2"), 0xc954de9b8fb3e5e2ULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xc954de9b8fb3e5e2ULL + 0xc1ab))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartFunction(Eq("function 3"), 0xdff98c9a35386e1fULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xfdacb856e78bbf57ULL))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0xfdacb856e78bbf57ULL))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 // On Mac OS X, SLINE records can appear before the FUN stab to which they
 // belong, and their values are absolute addresses, not offsets.
 TEST_F(Stabs, LeadingLine) {
   stabs.set_endianness(kBigEndian);
   stabs.set_value_size(4);
   stabs
       .Stab(N_SO,    179, 27357, 0x8adabc15, "build directory/")
       .Stab(N_SO,     52, 53058, 0x4c7e3bf4, "compilation unit")
       .Stab(N_SOL,   165, 12086, 0x6a797ca3, "source file name")
       .Stab(N_SLINE, 229, 20015, 0x4cb3d7e0, "")
       .Stab(N_SLINE,  89, 43802, 0x4cba8b88, "")
       .Stab(N_FUN,   251, 51639, 0xce1b98fa, "rutabaga")
       .Stab(N_FUN,   218, 16113, 0x5798,     "")
       .Stab(N_SO,     52, 53058, 0xd4af4415, "");
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 StartCompilationUnit(StrEq("compilation unit"),
 x4c7e3bf4, StrEq("build directory/")))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 StartFunction(Eq("rutabaga"), 0xce1b98fa))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0x4cb3d7e0, StrEq("source file name"), 20015))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Line(0x4cba8b88, StrEq("source file name"), 43802))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndFunction(0xce1b98fa + 0x5798))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler, EndCompilationUnit(0xd4af4415))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 #if defined(HAVE_MACH_O_NLIST_H)
 // These tests have no meaning on non-Mach-O-based systems, as
 // only Mach-O uses N_SECT to represent public symbols.
 TEST_F(Stabs, OnePublicSymbol) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
   const uint32_t kExpectedAddress = 0x9000;
   const string kExpectedFunctionName("public_function");
   stabs
     .Stab(N_SECT, 1, 0, kExpectedAddress, kExpectedFunctionName);
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 Extern(StrEq(kExpectedFunctionName),
                        kExpectedAddress))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 TEST_F(Stabs, TwoPublicSymbols) {
   stabs.set_endianness(kLittleEndian);
   stabs.set_value_size(4);
   const uint32_t kExpectedAddress1 = 0xB0B0B0B0;
   const string kExpectedFunctionName1("public_function");
   const uint32_t kExpectedAddress2 = 0xF0F0F0F0;
   const string kExpectedFunctionName2("something else");
   stabs
     .Stab(N_SECT, 1, 0, kExpectedAddress1, kExpectedFunctionName1)
     .Stab(N_SECT, 1, 0, kExpectedAddress2, kExpectedFunctionName2);
   {
     InSequence s;
     EXPECT_CALL(mock_handler,
                 Extern(StrEq(kExpectedFunctionName1),
                        kExpectedAddress1))
         .WillOnce(Return(true));
     EXPECT_CALL(mock_handler,
                 Extern(StrEq(kExpectedFunctionName2),
                        kExpectedAddress2))
         .WillOnce(Return(true));
   }
   ASSERT_TRUE(ApplyHandlerToMockStabsData());
 }
 #endif
 } // anonymous namespace

The Tor Browser / annotate

toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc@129ffea94266 (annotated)

toolkit/crashreporter/google-breakpad/src/common/stabs_reader_unittest.cc