diff --git a/README.md b/README.md
index 47483536..cb988ce0 100644
--- a/README.md
+++ b/README.md
@@ -1,128 +1,132 @@
 
 # Google Test #
 
 [![Build Status](https://api.travis-ci.org/google/googletest.svg?branch=master)](https://travis-ci.org/google/googletest)
 [![Build status](https://ci.appveyor.com/api/projects/status/4o38plt0xbo1ubc8/branch/master?svg=true)](https://ci.appveyor.com/project/GoogleTestAppVeyor/googletest/branch/master)
 
+**PR FREEZE COMING SOON**
+
+We are working on a large refactoring that would make it hard to accept external PRs. *Really Soon Now* we will not be accepting new PRs until the refactoring has been completed. 
+
 **Future Plans**:
 * 1.8.x Release - [the 1.8.x](https://github.com/google/googletest/releases/tag/release-1.8.1) is the last release that works with pre-C++11 compilers. The 1.8.x will not accept any requests for any new features and any bugfix requests will only be accepted if proven "critical"
 * Post 1.8.x - work to improve/cleanup/pay technical debt. When this work is completed there will be a 1.9.x tagged release
 * Post 1.9.x googletest will follow [Abseil Live at Head philosophy](https://abseil.io/about/philosophy)
 
 
 Welcome to **Google Test**, Google's C++ test framework!
 
 This repository is a merger of the formerly separate GoogleTest and
 GoogleMock projects. These were so closely related that it makes sense to
 maintain and release them together.
 
 Please subscribe to the mailing list at googletestframework@googlegroups.com for questions, discussions, and development.  
 There is also an IRC channel on [OFTC](https://webchat.oftc.net/) (irc.oftc.net) #gtest available.  
 
 Getting started information for **Google Test** is available in the
 [Google Test Primer](googletest/docs/primer.md) documentation.
 
 **Google Mock** is an extension to Google Test for writing and using C++ mock
 classes.  See the separate [Google Mock documentation](googlemock/README.md).
 
 More detailed documentation for googletest (including build instructions) are
 in its interior [googletest/README.md](googletest/README.md) file.
 
 ## Features ##
 
   * An [xUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
   * Test discovery.
   * A rich set of assertions.
   * User-defined assertions.
   * Death tests.
   * Fatal and non-fatal failures.
   * Value-parameterized tests.
   * Type-parameterized tests.
   * Various options for running the tests.
   * XML test report generation.
 
 ## Platforms ##
 
 Google test has been used on a variety of platforms:
 
   * Linux
   * Mac OS X
   * Windows
   * Cygwin
   * MinGW
   * Windows Mobile
   * Symbian
 
 ## Who Is Using Google Test? ##
 
 In addition to many internal projects at Google, Google Test is also used by
 the following notable projects:
 
   * The [Chromium projects](http://www.chromium.org/) (behind the Chrome
     browser and Chrome OS).
   * The [LLVM](http://llvm.org/) compiler.
   * [Protocol Buffers](https://github.com/google/protobuf), Google's data
     interchange format.
   * The [OpenCV](http://opencv.org/) computer vision library.
   * [tiny-dnn](https://github.com/tiny-dnn/tiny-dnn): header only, dependency-free deep learning framework in C++11.
 
 ## Related Open Source Projects ##
 
 [GTest Runner](https://github.com/nholthaus/gtest-runner) is a Qt5 based automated test-runner and Graphical User Interface with powerful features for Windows and Linux platforms.
 
 [Google Test UI](https://github.com/ospector/gtest-gbar) is test runner that runs
 your test binary, allows you to track its progress via a progress bar, and
 displays a list of test failures. Clicking on one shows failure text. Google
 Test UI is written in C#.
 
 [GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event
 listener for Google Test that implements the
 [TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test
 result output. If your test runner understands TAP, you may find it useful.
 
 [gtest-parallel](https://github.com/google/gtest-parallel) is a test runner that
 runs tests from your binary in parallel to provide significant speed-up.
 
 [GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter) is a VS Code extension allowing to view Google Tests in a tree view, and run/debug your tests.
 
 ## Requirements ##
 
 Google Test is designed to have fairly minimal requirements to build
 and use with your projects, but there are some.  Currently, we support
 Linux, Windows, Mac OS X, and Cygwin.  We will also make our best
 effort to support other platforms (e.g. Solaris, AIX, and z/OS).
 However, since core members of the Google Test project have no access
 to these platforms, Google Test may have outstanding issues there.  If
 you notice any problems on your platform, please notify
 [googletestframework@googlegroups.com](https://groups.google.com/forum/#!forum/googletestframework). Patches for fixing them are
 even more welcome!
 
 ### Linux Requirements ###
 
 These are the base requirements to build and use Google Test from a source
 package (as described below):
 
   * GNU-compatible Make or gmake
   * POSIX-standard shell
   * POSIX(-2) Regular Expressions (regex.h)
   * A C++11-standard-compliant compiler
 
 ### Windows Requirements ###
 
   * Microsoft Visual C++ 2015 or newer
 
 ### Cygwin Requirements ###
 
   * Cygwin v1.5.25-14 or newer
 
 ### Mac OS X Requirements ###
 
   * Mac OS X v10.4 Tiger or newer
   * Xcode Developer Tools
 
 ## Contributing change
 
 Please read the [`CONTRIBUTING.md`](CONTRIBUTING.md) for details on
 how to contribute to this project.
 
 Happy testing!
diff --git a/googlemock/make/Makefile b/googlemock/make/Makefile
index 7c13e05f..386293a0 100644
--- a/googlemock/make/Makefile
+++ b/googlemock/make/Makefile
@@ -1,101 +1,117 @@
 # A sample Makefile for building both Google Mock and Google Test and
 # using them in user tests.  This file is self-contained, so you don't
 # need to use the Makefile in Google Test's source tree.  Please tweak
 # it to suit your environment and project.  You may want to move it to
 # your project's root directory.
 #
 # SYNOPSIS:
 #
 #   make [all]  - makes everything.
 #   make TARGET - makes the given target.
 #   make clean  - removes all files generated by make.
 
 # Please tweak the following variable definitions as needed by your
 # project, except GMOCK_HEADERS and GTEST_HEADERS, which you can use
 # in your own targets but shouldn't modify.
 
 # Points to the root of Google Test, relative to where this file is.
 # Remember to tweak this if you move this file, or if you want to use
 # a copy of Google Test at a different location.
 GTEST_DIR = ../../googletest
 
+# Points to the location of the Google Test libraries
+GTEST_LIB_DIR = .
+
 # Points to the root of Google Mock, relative to where this file is.
 # Remember to tweak this if you move this file.
 GMOCK_DIR = ..
 
 # Where to find user code.
 USER_DIR = ../test
 
 # Flags passed to the preprocessor.
 # Set Google Test and Google Mock's header directories as system
 # directories, such that the compiler doesn't generate warnings in
 # these headers.
 CPPFLAGS += -isystem $(GTEST_DIR)/include -isystem $(GMOCK_DIR)/include
 
 # Flags passed to the C++ compiler.
-CXXFLAGS += -g -Wall -Wextra -pthread
+CXXFLAGS += -g -Wall -Wextra -pthread -std=c++11
+
+# Google Test libraries
+GTEST_LIBS = libgtest.a libgtest_main.a libgmock.a libgmock_main.a
 
 # All tests produced by this Makefile.  Remember to add new tests you
 # created to the list.
 TESTS = gmock_test
 
 # All Google Test headers.  Usually you shouldn't change this
 # definition.
 GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
                 $(GTEST_DIR)/include/gtest/internal/*.h
 
 # All Google Mock headers. Note that all Google Test headers are
 # included here too, as they are #included by Google Mock headers.
 # Usually you shouldn't change this definition.	
 GMOCK_HEADERS = $(GMOCK_DIR)/include/gmock/*.h \
                 $(GMOCK_DIR)/include/gmock/internal/*.h \
                 $(GTEST_HEADERS)
 
 # House-keeping build targets.
 
-all : $(TESTS)
+all : $(GTEST_LIBS) $(TESTS)
 
 clean :
-	rm -f $(TESTS) gmock.a gmock_main.a *.o
+	rm -f $(GTEST_LIBS) $(TESTS) *.o
 
 # Builds gmock.a and gmock_main.a.  These libraries contain both
 # Google Mock and Google Test.  A test should link with either gmock.a
 # or gmock_main.a, depending on whether it defines its own main()
 # function.  It's fine if your test only uses features from Google
 # Test (and not Google Mock).
 
 # Usually you shouldn't tweak such internal variables, indicated by a
 # trailing _.
 GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
 GMOCK_SRCS_ = $(GMOCK_DIR)/src/*.cc $(GMOCK_HEADERS)
 
 # For simplicity and to avoid depending on implementation details of
 # Google Mock and Google Test, the dependencies specified below are
 # conservative and not optimized.  This is fine as Google Mock and
 # Google Test compile fast and for ordinary users their source rarely
 # changes.
 gtest-all.o : $(GTEST_SRCS_)
 	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
             -c $(GTEST_DIR)/src/gtest-all.cc
 
+gtest_main.o : $(GTEST_SRCS_)
+	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
+            -c $(GTEST_DIR)/src/gtest_main.cc
+
 gmock-all.o : $(GMOCK_SRCS_)
 	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
             -c $(GMOCK_DIR)/src/gmock-all.cc
 
 gmock_main.o : $(GMOCK_SRCS_)
 	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) -I$(GMOCK_DIR) $(CXXFLAGS) \
             -c $(GMOCK_DIR)/src/gmock_main.cc
 
-gmock.a : gmock-all.o gtest-all.o
+libgtest.a : gtest-all.o
+	$(AR) $(ARFLAGS) $@ $^
+
+libgtest_main.a : gtest_main.o
+	$(AR) $(ARFLAGS) $@ $^
+
+libgmock.a : gmock-all.o
 	$(AR) $(ARFLAGS) $@ $^
 
-gmock_main.a : gmock-all.o gtest-all.o gmock_main.o
+libgmock_main.a : gmock_main.o
 	$(AR) $(ARFLAGS) $@ $^
 
 # Builds a sample test.
 
 gmock_test.o : $(USER_DIR)/gmock_test.cc $(GMOCK_HEADERS)
 	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/gmock_test.cc
 
-gmock_test : gmock_test.o gmock_main.a
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
+gmock_test : gmock_test.o $(GTEST_LIBS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -L$(GTEST_LIB_DIR) -lgmock -lpthread $^ -o $@
diff --git a/googletest/docs/advanced.md b/googletest/docs/advanced.md
index 05524809..dbe6694a 100644
--- a/googletest/docs/advanced.md
+++ b/googletest/docs/advanced.md
@@ -1,2520 +1,2520 @@
 # Advanced googletest Topics
 
 
 ## Introduction
 
 Now that you have read the [googletest Primer](primer.md) and learned how to write
 tests using googletest, it's time to learn some new tricks. This document will
 show you more assertions as well as how to construct complex failure messages,
 propagate fatal failures, reuse and speed up your test fixtures, and use various
 flags with your tests.
 
 ## More Assertions
 
 This section covers some less frequently used, but still significant,
 assertions.
 
 ### Explicit Success and Failure
 
 These three assertions do not actually test a value or expression. Instead, they
 generate a success or failure directly. Like the macros that actually perform a
 test, you may stream a custom failure message into them.
 
 ```c++
 SUCCEED();
 ```
 
 Generates a success. This does **NOT** make the overall test succeed. A test is
 considered successful only if none of its assertions fail during its execution.
 
 NOTE: `SUCCEED()` is purely documentary and currently doesn't generate any
 user-visible output. However, we may add `SUCCEED()` messages to googletest's
 output in the future.
 
 ```c++
 FAIL();
 ADD_FAILURE();
 ADD_FAILURE_AT("file_path", line_number);
 ```
 
 `FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()`
 generate a nonfatal failure. These are useful when control flow, rather than a
 Boolean expression, determines the test's success or failure. For example, you
 might want to write something like:
 
 ```c++
 switch(expression) {
   case 1:
      ... some checks ...
   case 2:
      ... some other checks ...
   default:
      FAIL() << "We shouldn't get here.";
 }
 ```
 
 NOTE: you can only use `FAIL()` in functions that return `void`. See the
 [Assertion Placement section](#assertion-placement) for more information.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Exception Assertions
 
 These are for verifying that a piece of code throws (or does not throw) an
 exception of the given type:
 
 Fatal assertion                            | Nonfatal assertion                         | Verifies
 ------------------------------------------ | ------------------------------------------ | --------
 `ASSERT_THROW(statement, exception_type);` | `EXPECT_THROW(statement, exception_type);` | `statement` throws an exception of the given type
 `ASSERT_ANY_THROW(statement);`             | `EXPECT_ANY_THROW(statement);`             | `statement` throws an exception of any type
 `ASSERT_NO_THROW(statement);`              | `EXPECT_NO_THROW(statement);`              | `statement` doesn't throw any exception
 
 Examples:
 
 ```c++
 ASSERT_THROW(Foo(5), bar_exception);
 
 EXPECT_NO_THROW({
   int n = 5;
   Bar(&n);
 });
 ```
 
 **Availability**: Linux, Windows, Mac; requires exceptions to be enabled in the
 build environment (note that `google3` **disables** exceptions).
 
 ### Predicate Assertions for Better Error Messages
 
 Even though googletest has a rich set of assertions, they can never be complete,
 as it's impossible (nor a good idea) to anticipate all scenarios a user might
 run into. Therefore, sometimes a user has to use `EXPECT_TRUE()` to check a
 complex expression, for lack of a better macro. This has the problem of not
 showing you the values of the parts of the expression, making it hard to
 understand what went wrong. As a workaround, some users choose to construct the
 failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
 is awkward especially when the expression has side-effects or is expensive to
 evaluate.
 
 googletest gives you three different options to solve this problem:
 
 #### Using an Existing Boolean Function
 
 If you already have a function or functor that returns `bool` (or a type that
 can be implicitly converted to `bool`), you can use it in a *predicate
 assertion* to get the function arguments printed for free:
 
 | Fatal assertion                    | Nonfatal assertion                 | Verifies                    |
 | ---------------------------------- | ---------------------------------- | --------------------------- |
 | `ASSERT_PRED1(pred1, val1);`       | `EXPECT_PRED1(pred1, val1);`       | `pred1(val1)` is true       |
 | `ASSERT_PRED2(pred2, val1, val2);` | `EXPECT_PRED2(pred2, val1, val2);` | `pred2(val1, val2)` is true |
 | `...`                              | `...`                              | ...                         |
 
 In the above, `predn` is an `n`-ary predicate function or functor, where `val1`,
 `val2`, ..., and `valn` are its arguments. The assertion succeeds if the
 predicate returns `true` when applied to the given arguments, and fails
 otherwise. When the assertion fails, it prints the value of each argument. In
 either case, the arguments are evaluated exactly once.
 
 Here's an example. Given
 
 ```c++
 // Returns true if m and n have no common divisors except 1.
 bool MutuallyPrime(int m, int n) { ... }
 
 const int a = 3;
 const int b = 4;
 const int c = 10;
 ```
 
 the assertion
 
 ```c++
   EXPECT_PRED2(MutuallyPrime, a, b);
 ```
 
 will succeed, while the assertion
 
 ```c++
   EXPECT_PRED2(MutuallyPrime, b, c);
 ```
 
 will fail with the message
 
 ```none
 MutuallyPrime(b, c) is false, where
 b is 4
 c is 10
 ```
 
 > NOTE:
 >
 > 1.  If you see a compiler error "no matching function to call" when using
 >     `ASSERT_PRED*` or `EXPECT_PRED*`, please see
 >     [this](faq.md#the-compiler-complains-no-matching-function-to-call-when-i-use-assert_pred-how-do-i-fix-it) for how to resolve it.
 > 1.  Currently we only provide predicate assertions of arity <= 5. If you need
 >     a higher-arity assertion, let [us](https://github.com/google/googletest/issues) know.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Using a Function That Returns an AssertionResult
 
 While `EXPECT_PRED*()` and friends are handy for a quick job, the syntax is not
 satisfactory: you have to use different macros for different arities, and it
 feels more like Lisp than C++. The `::testing::AssertionResult` class solves
 this problem.
 
 An `AssertionResult` object represents the result of an assertion (whether it's
 a success or a failure, and an associated message). You can create an
 `AssertionResult` using one of these factory functions:
 
 ```c++
 namespace testing {
 
 // Returns an AssertionResult object to indicate that an assertion has
 // succeeded.
 AssertionResult AssertionSuccess();
 
 // Returns an AssertionResult object to indicate that an assertion has
 // failed.
 AssertionResult AssertionFailure();
 
 }
 ```
 
 You can then use the `<<` operator to stream messages to the `AssertionResult`
 object.
 
 To provide more readable messages in Boolean assertions (e.g. `EXPECT_TRUE()`),
 write a predicate function that returns `AssertionResult` instead of `bool`. For
 example, if you define `IsEven()` as:
 
 ```c++
 ::testing::AssertionResult IsEven(int n) {
   if ((n % 2) == 0)
      return ::testing::AssertionSuccess();
   else
      return ::testing::AssertionFailure() << n << " is odd";
 }
 ```
 
 instead of:
 
 ```c++
 bool IsEven(int n) {
   return (n % 2) == 0;
 }
 ```
 
 the failed assertion `EXPECT_TRUE(IsEven(Fib(4)))` will print:
 
 ```none
 Value of: IsEven(Fib(4))
   Actual: false (3 is odd)
 Expected: true
 ```
 
 instead of a more opaque
 
 ```none
 Value of: IsEven(Fib(4))
   Actual: false
 Expected: true
 ```
 
 If you want informative messages in `EXPECT_FALSE` and `ASSERT_FALSE` as well
 (one third of Boolean assertions in the Google code base are negative ones), and
 are fine with making the predicate slower in the success case, you can supply a
 success message:
 
 ```c++
 ::testing::AssertionResult IsEven(int n) {
   if ((n % 2) == 0)
      return ::testing::AssertionSuccess() << n << " is even";
   else
      return ::testing::AssertionFailure() << n << " is odd";
 }
 ```
 
 Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print
 
 ```none
   Value of: IsEven(Fib(6))
      Actual: true (8 is even)
   Expected: false
 ```
 
 **Availability**: Linux, Windows, Mac.
 
 #### Using a Predicate-Formatter
 
 If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and
 `(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your
 predicate do not support streaming to `ostream`, you can instead use the
 following *predicate-formatter assertions* to *fully* customize how the message
 is formatted:
 
 Fatal assertion                                  | Nonfatal assertion                               | Verifies
 ------------------------------------------------ | ------------------------------------------------ | --------
 `ASSERT_PRED_FORMAT1(pred_format1, val1);`       | `EXPECT_PRED_FORMAT1(pred_format1, val1);`       | `pred_format1(val1)` is successful
 `ASSERT_PRED_FORMAT2(pred_format2, val1, val2);` | `EXPECT_PRED_FORMAT2(pred_format2, val1, val2);` | `pred_format2(val1, val2)` is successful
 `...`                                            | `...`                                            | ...
 
 The difference between this and the previous group of macros is that instead of
 a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a *predicate-formatter*
 (`pred_formatn`), which is a function or functor with the signature:
 
 ```c++
 ::testing::AssertionResult PredicateFormattern(const char* expr1,
                                                const char* expr2,
                                                ...
                                                const char* exprn,
                                                T1 val1,
                                                T2 val2,
                                                ...
                                                Tn valn);
 ```
 
 where `val1`, `val2`, ..., and `valn` are the values of the predicate arguments,
 and `expr1`, `expr2`, ..., and `exprn` are the corresponding expressions as they
 appear in the source code. The types `T1`, `T2`, ..., and `Tn` can be either
 value types or reference types. For example, if an argument has type `Foo`, you
 can declare it as either `Foo` or `const Foo&`, whichever is appropriate.
 
 As an example, let's improve the failure message in `MutuallyPrime()`, which was
 used with `EXPECT_PRED2()`:
 
 ```c++
 // Returns the smallest prime common divisor of m and n,
 // or 1 when m and n are mutually prime.
 int SmallestPrimeCommonDivisor(int m, int n) { ... }
 
 // A predicate-formatter for asserting that two integers are mutually prime.
 ::testing::AssertionResult AssertMutuallyPrime(const char* m_expr,
                                                const char* n_expr,
                                                int m,
                                                int n) {
   if (MutuallyPrime(m, n)) return ::testing::AssertionSuccess();
 
   return ::testing::AssertionFailure() << m_expr << " and " << n_expr
       << " (" << m << " and " << n << ") are not mutually prime, "
       << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n);
 }
 ```
 
 With this predicate-formatter, we can use
 
 ```c++
   EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c);
 ```
 
 to generate the message
 
 ```none
 b and c (4 and 10) are not mutually prime, as they have a common divisor 2.
 ```
 
 As you may have realized, many of the built-in assertions we introduced earlier
 are special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are
 indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Floating-Point Comparison
 
 Comparing floating-point numbers is tricky. Due to round-off errors, it is very
 unlikely that two floating-points will match exactly. Therefore, `ASSERT_EQ` 's
 naive comparison usually doesn't work. And since floating-points can have a wide
 value range, no single fixed error bound works. It's better to compare by a
 fixed relative error bound, except for values close to 0 due to the loss of
 precision there.
 
 In general, for floating-point comparison to make sense, the user needs to
 carefully choose the error bound. If they don't want or care to, comparing in
 terms of Units in the Last Place (ULPs) is a good default, and googletest
 provides assertions to do this. Full details about ULPs are quite long; if you
 want to learn more, see
 [here](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
 
 #### Floating-Point Macros
 
 | Fatal assertion                 | Nonfatal assertion             | Verifies                                 |
 | ------------------------------- | ------------------------------ | ---------------------------------------- |
 | `ASSERT_FLOAT_EQ(val1, val2);`  | `EXPECT_FLOAT_EQ(val1,val2);`  | the two `float` values are almost equal  |
 | `ASSERT_DOUBLE_EQ(val1, val2);` | `EXPECT_DOUBLE_EQ(val1, val2);`| the two `double` values are almost equal |
 
 By "almost equal" we mean the values are within 4 ULP's from each other.
 
 NOTE: `CHECK_DOUBLE_EQ()` in `base/logging.h` uses a fixed absolute error bound,
 so its result may differ from that of the googletest macros. That macro is
 unsafe and has been deprecated. Please don't use it any more.
 
 The following assertions allow you to choose the acceptable error bound:
 
 | Fatal assertion                       | Nonfatal assertion                    | Verifies                  |
 | ------------------------------------- | ------------------------------------- | ------------------------- |
 | `ASSERT_NEAR(val1, val2, abs_error);` | `EXPECT_NEAR(val1, val2, abs_error);` | the difference between `val1` and `val2` doesn't exceed the given absolute error |
 
 **Availability**: Linux, Windows, Mac.
 
 #### Floating-Point Predicate-Format Functions
 
 Some floating-point operations are useful, but not that often used. In order to
 avoid an explosion of new macros, we provide them as predicate-format functions
 that can be used in predicate assertion macros (e.g. `EXPECT_PRED_FORMAT2`,
 etc).
 
 ```c++
 EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2);
 EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2);
 ```
 
 Verifies that `val1` is less than, or almost equal to, `val2`. You can replace
 `EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Asserting Using gMock Matchers
 
 Google-developed C++ mocking framework [gMock](../../googlemock) comes with a
 library of matchers for validating arguments passed to mock objects. A gMock
 *matcher* is basically a predicate that knows how to describe itself. It can be
 used in these assertion macros:
 
 | Fatal assertion                | Nonfatal assertion             | Verifies              |
 | ------------------------------ | ------------------------------ | --------------------- |
 | `ASSERT_THAT(value, matcher);` | `EXPECT_THAT(value, matcher);` | value matches matcher |
 
 For example, `StartsWith(prefix)` is a matcher that matches a string starting
 with `prefix`, and you can write:
 
 ```c++
 using ::testing::StartsWith;
 ...
     // Verifies that Foo() returns a string starting with "Hello".
     EXPECT_THAT(Foo(), StartsWith("Hello"));
 ```
 
 Read this [recipe](../../googlemock/docs/CookBook.md#using-matchers-in-google-test-assertions) in
 the gMock Cookbook for more details.
 
 gMock has a rich set of matchers. You can do many things googletest cannot do
 alone with them. For a list of matchers gMock provides, read
 [this](../../googlemock/docs/CookBook.md#using-matchers). Especially useful among them are
 some [protocol buffer matchers](https://github.com/google/nucleus/blob/master/nucleus/testing/protocol-buffer-matchers.h). It's easy to write
 your [own matchers](../../googlemock/docs/CookBook.md#writing-new-matchers-quickly) too.
 
 For example, you can use gMock's
 [EqualsProto](https://github.com/google/nucleus/blob/master/nucleus/testing/protocol-buffer-matchers.h)
 to compare protos in your tests:
 
 ```c++
 #include "testing/base/public/gmock.h"
 using ::testing::EqualsProto;
 ...
     EXPECT_THAT(actual_proto, EqualsProto("foo: 123 bar: 'xyz'"));
     EXPECT_THAT(*actual_proto_ptr, EqualsProto(expected_proto));
 ```
 
 gMock is bundled with googletest, so you don't need to add any build dependency
 in order to take advantage of this. Just include `"testing/base/public/gmock.h"`
 and you're ready to go.
 
 **Availability**: Linux, Windows, and Mac.
 
 ### More String Assertions
 
 (Please read the [previous](#asserting-using-gmock-matchers) section first if you haven't.)
 
 You can use the gMock [string matchers](../../googlemock/docs/CheatSheet.md#string-matchers)
 with `EXPECT_THAT()` or `ASSERT_THAT()` to do more string comparison tricks
 (sub-string, prefix, suffix, regular expression, and etc). For example,
 
 ```c++
 using ::testing::HasSubstr;
 using ::testing::MatchesRegex;
 ...
   ASSERT_THAT(foo_string, HasSubstr("needle"));
   EXPECT_THAT(bar_string, MatchesRegex("\\w*\\d+"));
 ```
 
 **Availability**: Linux, Windows, Mac.
 
 If the string contains a well-formed HTML or XML document, you can check whether
 its DOM tree matches an [XPath
 expression](http://www.w3.org/TR/xpath/#contents):
 
 ```c++
 // Currently still in //template/prototemplate/testing:xpath_matcher
 #include "template/prototemplate/testing/xpath_matcher.h"
 using prototemplate::testing::MatchesXPath;
 EXPECT_THAT(html_string, MatchesXPath("//a[text()='click here']"));
 ```
 
 **Availability**: Linux.
 
 ### Windows HRESULT assertions
 
 These assertions test for `HRESULT` success or failure.
 
 Fatal assertion                        | Nonfatal assertion                     | Verifies
 -------------------------------------- | -------------------------------------- | --------
 `ASSERT_HRESULT_SUCCEEDED(expression)` | `EXPECT_HRESULT_SUCCEEDED(expression)` | `expression` is a success `HRESULT`
 `ASSERT_HRESULT_FAILED(expression)`    | `EXPECT_HRESULT_FAILED(expression)`    | `expression` is a failure `HRESULT`
 
 The generated output contains the human-readable error message associated with
 the `HRESULT` code returned by `expression`.
 
 You might use them like this:
 
 ```c++
 CComPtr<IShellDispatch2> shell;
 ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application"));
 CComVariant empty;
 ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty));
 ```
 
 **Availability**: Windows.
 
 ### Type Assertions
 
 You can call the function
 
 ```c++
 ::testing::StaticAssertTypeEq<T1, T2>();
 ```
 
 to assert that types `T1` and `T2` are the same. The function does nothing if
 the assertion is satisfied. If the types are different, the function call will
 fail to compile, and the compiler error message will likely (depending on the
 compiler) show you the actual values of `T1` and `T2`. This is mainly useful
 inside template code.
 
 **Caveat**: When used inside a member function of a class template or a function
 template, `StaticAssertTypeEq<T1, T2>()` is effective only if the function is
 instantiated. For example, given:
 
 ```c++
 template <typename T> class Foo {
  public:
   void Bar() { ::testing::StaticAssertTypeEq<int, T>(); }
 };
 ```
 
 the code:
 
 ```c++
 void Test1() { Foo<bool> foo; }
 ```
 
 will not generate a compiler error, as `Foo<bool>::Bar()` is never actually
 instantiated. Instead, you need:
 
 ```c++
 void Test2() { Foo<bool> foo; foo.Bar(); }
 ```
 
 to cause a compiler error.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Assertion Placement
 
 You can use assertions in any C++ function. In particular, it doesn't have to be
 a method of the test fixture class. The one constraint is that assertions that
 generate a fatal failure (`FAIL*` and `ASSERT_*`) can only be used in
 void-returning functions. This is a consequence of Google's not using
 exceptions. By placing it in a non-void function you'll get a confusing compile
 error like `"error: void value not ignored as it ought to be"` or `"cannot
 initialize return object of type 'bool' with an rvalue of type 'void'"` or
 `"error: no viable conversion from 'void' to 'string'"`.
 
 If you need to use fatal assertions in a function that returns non-void, one
 option is to make the function return the value in an out parameter instead. For
 example, you can rewrite `T2 Foo(T1 x)` to `void Foo(T1 x, T2* result)`. You
 need to make sure that `*result` contains some sensible value even when the
 function returns prematurely. As the function now returns `void`, you can use
 any assertion inside of it.
 
 If changing the function's type is not an option, you should just use assertions
 that generate non-fatal failures, such as `ADD_FAILURE*` and `EXPECT_*`.
 
 NOTE: Constructors and destructors are not considered void-returning functions,
 according to the C++ language specification, and so you may not use fatal
 assertions in them. You'll get a compilation error if you try. A simple
 workaround is to transfer the entire body of the constructor or destructor to a
 private void-returning method. However, you should be aware that a fatal
 assertion failure in a constructor does not terminate the current test, as your
 intuition might suggest; it merely returns from the constructor early, possibly
 leaving your object in a partially-constructed state. Likewise, a fatal
 assertion failure in a destructor may leave your object in a
 partially-destructed state. Use assertions carefully in these situations!
 
 ## Teaching googletest How to Print Your Values
 
 When a test assertion such as `EXPECT_EQ` fails, googletest prints the argument
 values to help you debug. It does this using a user-extensible value printer.
 
 This printer knows how to print built-in C++ types, native arrays, STL
 containers, and any type that supports the `<<` operator. For other types, it
 prints the raw bytes in the value and hopes that you the user can figure it out.
 
 As mentioned earlier, the printer is *extensible*. That means you can teach it
 to do a better job at printing your particular type than to dump the bytes. To
 do that, define `<<` for your type:
 
 ```c++
 // Streams are allowed only for logging.  Don't include this for
 // any other purpose.
 #include <ostream>
 
 namespace foo {
 
 class Bar {  // We want googletest to be able to print instances of this.
 ...
   // Create a free inline friend function.
   friend std::ostream& operator<<(std::ostream& os, const Bar& bar) {
     return os << bar.DebugString();  // whatever needed to print bar to os
   }
 };
 
 // If you can't declare the function in the class it's important that the
 // << operator is defined in the SAME namespace that defines Bar.  C++'s look-up
 // rules rely on that.
 std::ostream& operator<<(std::ostream& os, const Bar& bar) {
   return os << bar.DebugString();  // whatever needed to print bar to os
 }
 
 }  // namespace foo
 ```
 
 Sometimes, this might not be an option: your team may consider it bad style to
 have a `<<` operator for `Bar`, or `Bar` may already have a `<<` operator that
 doesn't do what you want (and you cannot change it). If so, you can instead
 define a `PrintTo()` function like this:
 
 ```c++
 // Streams are allowed only for logging.  Don't include this for
 // any other purpose.
 #include <ostream>
 
 namespace foo {
 
 class Bar {
   ...
   friend void PrintTo(const Bar& bar, std::ostream* os) {
     *os << bar.DebugString();  // whatever needed to print bar to os
   }
 };
 
 // If you can't declare the function in the class it's important that PrintTo()
 // is defined in the SAME namespace that defines Bar.  C++'s look-up rules rely
 // on that.
 void PrintTo(const Bar& bar, std::ostream* os) {
   *os << bar.DebugString();  // whatever needed to print bar to os
 }
 
 }  // namespace foo
 ```
 
 If you have defined both `<<` and `PrintTo()`, the latter will be used when
 googletest is concerned. This allows you to customize how the value appears in
 googletest's output without affecting code that relies on the behavior of its
 `<<` operator.
 
 If you want to print a value `x` using googletest's value printer yourself, just
 call `::testing::PrintToString(x)`, which returns an `std::string`:
 
 ```c++
 vector<pair<Bar, int> > bar_ints = GetBarIntVector();
 
 EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
     << "bar_ints = " << ::testing::PrintToString(bar_ints);
 ```
 
 ## Death Tests
 
 In many applications, there are assertions that can cause application failure if
 a condition is not met. These sanity checks, which ensure that the program is in
 a known good state, are there to fail at the earliest possible time after some
 program state is corrupted. If the assertion checks the wrong condition, then
 the program may proceed in an erroneous state, which could lead to memory
 corruption, security holes, or worse. Hence it is vitally important to test that
 such assertion statements work as expected.
 
 Since these precondition checks cause the processes to die, we call such tests
 _death tests_. More generally, any test that checks that a program terminates
 (except by throwing an exception) in an expected fashion is also a death test.
 
 
 Note that if a piece of code throws an exception, we don't consider it "death"
 for the purpose of death tests, as the caller of the code could catch the
 exception and avoid the crash. If you want to verify exceptions thrown by your
 code, see [Exception Assertions](#exception-assertions).
 
 If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see
 Catching Failures
 
 ### How to Write a Death Test
 
 googletest has the following macros to support death tests:
 
 Fatal assertion                                | Nonfatal assertion                             | Verifies
 ---------------------------------------------- | ---------------------------------------------- | --------
 `ASSERT_DEATH(statement, regex);`              | `EXPECT_DEATH(statement, regex);`              | `statement` crashes with the given error
 `ASSERT_DEATH_IF_SUPPORTED(statement, regex);` | `EXPECT_DEATH_IF_SUPPORTED(statement, regex);` | if death tests are supported, verifies that `statement` crashes with the given error; otherwise verifies nothing
 `ASSERT_EXIT(statement, predicate, regex);`    | `EXPECT_EXIT(statement, predicate, regex);`    | `statement` exits with the given error, and its exit code matches `predicate`
 
 where `statement` is a statement that is expected to cause the process to die,
 `predicate` is a function or function object that evaluates an integer exit
 status, and `regex` is a (Perl) regular expression that the stderr output of
 `statement` is expected to match. Note that `statement` can be *any valid
 statement* (including *compound statement*) and doesn't have to be an
 expression.
 
 
 As usual, the `ASSERT` variants abort the current test function, while the
 `EXPECT` variants do not.
 
 > NOTE: We use the word "crash" here to mean that the process terminates with a
 > *non-zero* exit status code. There are two possibilities: either the process
 > has called `exit()` or `_exit()` with a non-zero value, or it may be killed by
 > a signal.
 >
 > This means that if `*statement*` terminates the process with a 0 exit code, it
 > is *not* considered a crash by `EXPECT_DEATH`. Use `EXPECT_EXIT` instead if
 > this is the case, or if you want to restrict the exit code more precisely.
 
 A predicate here must accept an `int` and return a `bool`. The death test
 succeeds only if the predicate returns `true`. googletest defines a few
 predicates that handle the most common cases:
 
 ```c++
 ::testing::ExitedWithCode(exit_code)
 ```
 
 This expression is `true` if the program exited normally with the given exit
 code.
 
 ```c++
 ::testing::KilledBySignal(signal_number)  // Not available on Windows.
 ```
 
 This expression is `true` if the program was killed by the given signal.
 
 The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate
 that verifies the process' exit code is non-zero.
 
 Note that a death test only cares about three things:
 
 1.  does `statement` abort or exit the process?
 2.  (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status
     satisfy `predicate`? Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`)
     is the exit status non-zero? And
 3.  does the stderr output match `regex`?
 
 In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it
 will **not** cause the death test to fail, as googletest assertions don't abort
 the process.
 
 To write a death test, simply use one of the above macros inside your test
 function. For example,
 
 ```c++
 TEST(MyDeathTest, Foo) {
   // This death test uses a compound statement.
   ASSERT_DEATH({
     int n = 5;
     Foo(&n);
   }, "Error on line .* of Foo()");
 }
 
 TEST(MyDeathTest, NormalExit) {
   EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success");
 }
 
 TEST(MyDeathTest, KillMyself) {
   EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL),
               "Sending myself unblockable signal");
 }
 ```
 
 verifies that:
 
 *   calling `Foo(5)` causes the process to die with the given error message,
 *   calling `NormalExit()` causes the process to print `"Success"` to stderr and
     exit with exit code 0, and
 *   calling `KillMyself()` kills the process with signal `SIGKILL`.
 
 The test function body may contain other assertions and statements as well, if
 necessary.
 
 ### Death Test Naming
 
 IMPORTANT: We strongly recommend you to follow the convention of naming your
-**test case** (not test) `*DeathTest` when it contains a death test, as
+**test suite** (not test) `*DeathTest` when it contains a death test, as
 demonstrated in the above example. The [Death Tests And
 Threads](#death-tests-and-threads) section below explains why.
 
 If a test fixture class is shared by normal tests and death tests, you can use
 `using` or `typedef` to introduce an alias for the fixture class and avoid
 duplicating its code:
 
 ```c++
 class FooTest : public ::testing::Test { ... };
 
 using FooDeathTest = FooTest;
 
 TEST_F(FooTest, DoesThis) {
   // normal test
 }
 
 TEST_F(FooDeathTest, DoesThat) {
   // death test
 }
 ```
 
 **Availability**: Linux, Windows (requires MSVC 8.0 or above), Cygwin, and Mac
 
 ### Regular Expression Syntax
 
 
 On POSIX systems (e.g. Linux, Cygwin, and Mac), googletest uses the
 [POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
 syntax. To learn about this syntax, you may want to read this
 [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_Extended_Regular_Expressions).
 
 On Windows, googletest uses its own simple regular expression implementation. It
 lacks many features. For example, we don't support union (`"x|y"`), grouping
 (`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among
 others. Below is what we do support (`A` denotes a literal character, period
 (`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular
 expressions.):
 
 Expression | Meaning
 ---------- | --------------------------------------------------------------
 `c`        | matches any literal character `c`
 `\\d`      | matches any decimal digit
 `\\D`      | matches any character that's not a decimal digit
 `\\f`      | matches `\f`
 `\\n`      | matches `\n`
 `\\r`      | matches `\r`
 `\\s`      | matches any ASCII whitespace, including `\n`
 `\\S`      | matches any character that's not a whitespace
 `\\t`      | matches `\t`
 `\\v`      | matches `\v`
 `\\w`      | matches any letter, `_`, or decimal digit
 `\\W`      | matches any character that `\\w` doesn't match
 `\\c`      | matches any literal character `c`, which must be a punctuation
 `.`        | matches any single character except `\n`
 `A?`       | matches 0 or 1 occurrences of `A`
 `A*`       | matches 0 or many occurrences of `A`
 `A+`       | matches 1 or many occurrences of `A`
 `^`        | matches the beginning of a string (not that of each line)
 `$`        | matches the end of a string (not that of each line)
 `xy`       | matches `x` followed by `y`
 
 To help you determine which capability is available on your system, googletest
 defines macros to govern which regular expression it is using. The macros are:
 <!--absl:google3-begin(google3-only)-->`GTEST_USES_PCRE=1`, or
 <!--absl:google3-end--> `GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If
 you want your death tests to work in all cases, you can either `#if` on these
 macros or use the more limited syntax only.
 
 ### How It Works
 
 Under the hood, `ASSERT_EXIT()` spawns a new process and executes the death test
 statement in that process. The details of how precisely that happens depend on
 the platform and the variable ::testing::GTEST_FLAG(death_test_style) (which is
 initialized from the command-line flag `--gtest_death_test_style`).
 
 *   On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the
     child, after which:
     *   If the variable's value is `"fast"`, the death test statement is
         immediately executed.
     *   If the variable's value is `"threadsafe"`, the child process re-executes
         the unit test binary just as it was originally invoked, but with some
         extra flags to cause just the single death test under consideration to
         be run.
 *   On Windows, the child is spawned using the `CreateProcess()` API, and
     re-executes the binary to cause just the single death test under
     consideration to be run - much like the `threadsafe` mode on POSIX.
 
 Other values for the variable are illegal and will cause the death test to fail.
 Currently, the flag's default value is
 "fast". However, we reserve
 the right to change it in the future. Therefore, your tests should not depend on
 this. In either case, the parent process waits for the child process to
 complete, and checks that
 
 1.  the child's exit status satisfies the predicate, and
 2.  the child's stderr matches the regular expression.
 
 If the death test statement runs to completion without dying, the child process
 will nonetheless terminate, and the assertion fails.
 
 ### Death Tests And Threads
 
 The reason for the two death test styles has to do with thread safety. Due to
 well-known problems with forking in the presence of threads, death tests should
 be run in a single-threaded context. Sometimes, however, it isn't feasible to
 arrange that kind of environment. For example, statically-initialized modules
 may start threads before main is ever reached. Once threads have been created,
 it may be difficult or impossible to clean them up.
 
 googletest has three features intended to raise awareness of threading issues.
 
 1.  A warning is emitted if multiple threads are running when a death test is
     encountered.
-2.  Test cases with a name ending in "DeathTest" are run before all other tests.
+2.  Test suites with a name ending in "DeathTest" are run before all other tests.
 3.  It uses `clone()` instead of `fork()` to spawn the child process on Linux
     (`clone()` is not available on Cygwin and Mac), as `fork()` is more likely
     to cause the child to hang when the parent process has multiple threads.
 
 It's perfectly fine to create threads inside a death test statement; they are
 executed in a separate process and cannot affect the parent.
 
 ### Death Test Styles
 
 
 The "threadsafe" death test style was introduced in order to help mitigate the
 risks of testing in a possibly multithreaded environment. It trades increased
 test execution time (potentially dramatically so) for improved thread safety.
 
 The automated testing framework does not set the style flag. You can choose a
 particular style of death tests by setting the flag programmatically:
 
 ```c++
 testing::FLAGS_gtest_death_test_style="threadsafe"
 ```
 
 You can do this in `main()` to set the style for all death tests in the binary,
 or in individual tests. Recall that flags are saved before running each test and
 restored afterwards, so you need not do that yourself. For example:
 
 ```c++
 int main(int argc, char** argv) {
   InitGoogle(argv[0], &argc, &argv, true);
   ::testing::FLAGS_gtest_death_test_style = "fast";
   return RUN_ALL_TESTS();
 }
 
 TEST(MyDeathTest, TestOne) {
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
   // This test is run in the "threadsafe" style:
   ASSERT_DEATH(ThisShouldDie(), "");
 }
 
 TEST(MyDeathTest, TestTwo) {
   // This test is run in the "fast" style:
   ASSERT_DEATH(ThisShouldDie(), "");
 }
 ```
 
 
 ### Caveats
 
 The `statement` argument of `ASSERT_EXIT()` can be any valid C++ statement. If
 it leaves the current function via a `return` statement or by throwing an
 exception, the death test is considered to have failed. Some googletest macros
 may return from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid
 them in `statement`.
 
 Since `statement` runs in the child process, any in-memory side effect (e.g.
 modifying a variable, releasing memory, etc) it causes will *not* be observable
 in the parent process. In particular, if you release memory in a death test,
 your program will fail the heap check as the parent process will never see the
 memory reclaimed. To solve this problem, you can
 
 1.  try not to free memory in a death test;
 2.  free the memory again in the parent process; or
 3.  do not use the heap checker in your program.
 
 Due to an implementation detail, you cannot place multiple death test assertions
 on the same line; otherwise, compilation will fail with an unobvious error
 message.
 
 Despite the improved thread safety afforded by the "threadsafe" style of death
 test, thread problems such as deadlock are still possible in the presence of
 handlers registered with `pthread_atfork(3)`.
 
 
 ## Using Assertions in Sub-routines
 
 ### Adding Traces to Assertions
 
 If a test sub-routine is called from several places, when an assertion inside it
 fails, it can be hard to tell which invocation of the sub-routine the failure is
-from. 
+from.
 You can alleviate this problem using extra logging or custom failure messages,
 but that usually clutters up your tests. A better solution is to use the
 `SCOPED_TRACE` macro or the `ScopedTrace` utility:
 
 ```c++
 SCOPED_TRACE(message);
 ScopedTrace trace("file_path", line_number, message);
 ```
 
 where `message` can be anything streamable to `std::ostream`. `SCOPED_TRACE`
 macro will cause the current file name, line number, and the given message to be
 added in every failure message. `ScopedTrace` accepts explicit file name and
 line number in arguments, which is useful for writing test helpers. The effect
 will be undone when the control leaves the current lexical scope.
 
 For example,
 
 ```c++
 10: void Sub1(int n) {
 11:   EXPECT_EQ(1, Bar(n));
 12:   EXPECT_EQ(2, Bar(n + 1));
 13: }
 14:
 15: TEST(FooTest, Bar) {
 16:   {
 17:     SCOPED_TRACE("A");  // This trace point will be included in
 18:                         // every failure in this scope.
 19:     Sub1(1);
 20:   }
 21:   // Now it won't.
 22:   Sub1(9);
 23: }
 ```
 
 could result in messages like these:
 
 ```none
 path/to/foo_test.cc:11: Failure
 Value of: Bar(n)
 Expected: 1
   Actual: 2
    Trace:
 path/to/foo_test.cc:17: A
 
 path/to/foo_test.cc:12: Failure
 Value of: Bar(n + 1)
 Expected: 2
   Actual: 3
 ```
 
 Without the trace, it would've been difficult to know which invocation of
 `Sub1()` the two failures come from respectively. (You could add
 
 an extra message to each assertion in `Sub1()` to indicate the value of `n`, but
 that's tedious.)
 
 Some tips on using `SCOPED_TRACE`:
 
 1.  With a suitable message, it's often enough to use `SCOPED_TRACE` at the
     beginning of a sub-routine, instead of at each call site.
 2.  When calling sub-routines inside a loop, make the loop iterator part of the
     message in `SCOPED_TRACE` such that you can know which iteration the failure
     is from.
 3.  Sometimes the line number of the trace point is enough for identifying the
     particular invocation of a sub-routine. In this case, you don't have to
     choose a unique message for `SCOPED_TRACE`. You can simply use `""`.
 4.  You can use `SCOPED_TRACE` in an inner scope when there is one in the outer
     scope. In this case, all active trace points will be included in the failure
     messages, in reverse order they are encountered.
 5.  The trace dump is clickable in Emacs - hit `return` on a line number and
     you'll be taken to that line in the source file!
 
 **Availability**: Linux, Windows, Mac.
 
 ### Propagating Fatal Failures
 
 A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
 when they fail they only abort the _current function_, not the entire test. For
 example, the following test will segfault:
 
 ```c++
 void Subroutine() {
   // Generates a fatal failure and aborts the current function.
   ASSERT_EQ(1, 2);
 
   // The following won't be executed.
   ...
 }
 
 TEST(FooTest, Bar) {
   Subroutine();  // The intended behavior is for the fatal failure
                  // in Subroutine() to abort the entire test.
 
   // The actual behavior: the function goes on after Subroutine() returns.
   int* p = NULL;
   *p = 3;  // Segfault!
 }
 ```
 
 To alleviate this, googletest provides three different solutions. You could use
 either exceptions, the `(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
 `HasFatalFailure()` function. They are described in the following two
 subsections.
 
 #### Asserting on Subroutines with an exception
 
 The following code can turn ASSERT-failure into an exception:
 
 ```c++
 class ThrowListener : public testing::EmptyTestEventListener {
   void OnTestPartResult(const testing::TestPartResult& result) override {
     if (result.type() == testing::TestPartResult::kFatalFailure) {
       throw testing::AssertionException(result);
     }
   }
 };
 int main(int argc, char** argv) {
   ...
   testing::UnitTest::GetInstance()->listeners().Append(new ThrowListener);
   return RUN_ALL_TESTS();
 }
 ```
 
 This listener should be added after other listeners if you have any, otherwise
 they won't see failed `OnTestPartResult`.
 
 #### Asserting on Subroutines
 
 As shown above, if your test calls a subroutine that has an `ASSERT_*` failure
 in it, the test will continue after the subroutine returns. This may not be what
 you want.
 
 Often people want fatal failures to propagate like exceptions. For that
 googletest offers the following macros:
 
 Fatal assertion                       | Nonfatal assertion                    | Verifies
 ------------------------------------- | ------------------------------------- | --------
 `ASSERT_NO_FATAL_FAILURE(statement);` | `EXPECT_NO_FATAL_FAILURE(statement);` | `statement` doesn't generate any new fatal failures in the current thread.
 
 Only failures in the thread that executes the assertion are checked to determine
 the result of this type of assertions. If `statement` creates new threads,
 failures in these threads are ignored.
 
 Examples:
 
 ```c++
 ASSERT_NO_FATAL_FAILURE(Foo());
 
 int i;
 EXPECT_NO_FATAL_FAILURE({
   i = Bar();
 });
 ```
 
 **Availability**: Linux, Windows, Mac. Assertions from multiple threads are
 currently not supported on Windows.
 
 #### Checking for Failures in the Current Test
 
 `HasFatalFailure()` in the `::testing::Test` class returns `true` if an
 assertion in the current test has suffered a fatal failure. This allows
 functions to catch fatal failures in a sub-routine and return early.
 
 ```c++
 class Test {
  public:
   ...
   static bool HasFatalFailure();
 };
 ```
 
 The typical usage, which basically simulates the behavior of a thrown exception,
 is:
 
 ```c++
 TEST(FooTest, Bar) {
   Subroutine();
   // Aborts if Subroutine() had a fatal failure.
   if (HasFatalFailure()) return;
 
   // The following won't be executed.
   ...
 }
 ```
 
 If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test
 fixture, you must add the `::testing::Test::` prefix, as in:
 
 ```c++
 if (::testing::Test::HasFatalFailure()) return;
 ```
 
 Similarly, `HasNonfatalFailure()` returns `true` if the current test has at
 least one non-fatal failure, and `HasFailure()` returns `true` if the current
 test has at least one failure of either kind.
 
 **Availability**: Linux, Windows, Mac.
 
 ## Logging Additional Information
 
 In your test code, you can call `RecordProperty("key", value)` to log additional
 information, where `value` can be either a string or an `int`. The *last* value
 recorded for a key will be emitted to the [XML output](#generating-an-xml-report) if you
 specify one. For example, the test
 
 ```c++
 TEST_F(WidgetUsageTest, MinAndMaxWidgets) {
   RecordProperty("MaximumWidgets", ComputeMaxUsage());
   RecordProperty("MinimumWidgets", ComputeMinUsage());
 }
 ```
 
 will output XML like this:
 
 ```xml
   ...
     <testcase name="MinAndMaxWidgets" status="run" time="0.006" classname="WidgetUsageTest" MaximumWidgets="12" MinimumWidgets="9" />
   ...
 ```
 
 > NOTE:
 >
 > *   `RecordProperty()` is a static member of the `Test` class. Therefore it
 >     needs to be prefixed with `::testing::Test::` if used outside of the
 >     `TEST` body and the test fixture class.
 > *   `*key*` must be a valid XML attribute name, and cannot conflict with the
 >     ones already used by googletest (`name`, `status`, `time`, `classname`,
 >     `type_param`, and `value_param`).
 > *   Calling `RecordProperty()` outside of the lifespan of a test is allowed.
->     If it's called outside of a test but between a test case's
->     `SetUpTestCase()` and `TearDownTestCase()` methods, it will be attributed
->     to the XML element for the test case. If it's called outside of all test
->     cases (e.g. in a test environment), it will be attributed to the top-level
+>     If it's called outside of a test but between a test suite's
+>     `SetUpTestSuite()` and `TearDownTestSuite()` methods, it will be attributed
+>     to the XML element for the test suite. If it's called outside of all test
+>     suites (e.g. in a test environment), it will be attributed to the top-level
 >     XML element.
 
 **Availability**: Linux, Windows, Mac.
 
-## Sharing Resources Between Tests in the Same Test Case
+## Sharing Resources Between Tests in the Same Test Suite
 
 googletest creates a new test fixture object for each test in order to make
 tests independent and easier to debug. However, sometimes tests use resources
 that are expensive to set up, making the one-copy-per-test model prohibitively
 expensive.
 
 If the tests don't change the resource, there's no harm in their sharing a
 single resource copy. So, in addition to per-test set-up/tear-down, googletest
-also supports per-test-case set-up/tear-down. To use it:
+also supports per-test-suite set-up/tear-down. To use it:
 
 1.  In your test fixture class (say `FooTest` ), declare as `static` some member
     variables to hold the shared resources.
 1.  Outside your test fixture class (typically just below it), define those
     member variables, optionally giving them initial values.
-1.  In the same test fixture class, define a `static void SetUpTestCase()`
-    function (remember not to spell it as **`SetupTestCase`** with a small `u`!)
-    to set up the shared resources and a `static void TearDownTestCase()`
+1.  In the same test fixture class, define a `static void SetUpTestSuite()`
+    function (remember not to spell it as **`SetUpTestSuite`** with a small `u`!)
+    to set up the shared resources and a `static void TearDownTestSuite()`
     function to tear them down.
 
-That's it! googletest automatically calls `SetUpTestCase()` before running the
-*first test* in the `FooTest` test case (i.e. before creating the first
-`FooTest` object), and calls `TearDownTestCase()` after running the *last test*
+That's it! googletest automatically calls `SetUpTestSuite()` before running the
+*first test* in the `FooTest` test suite (i.e. before creating the first
+`FooTest` object), and calls `TearDownTestSuite()` after running the *last test*
 in it (i.e. after deleting the last `FooTest` object). In between, the tests can
 use the shared resources.
 
 Remember that the test order is undefined, so your code can't depend on a test
 preceding or following another. Also, the tests must either not modify the state
 of any shared resource, or, if they do modify the state, they must restore the
 state to its original value before passing control to the next test.
 
-Here's an example of per-test-case set-up and tear-down:
+Here's an example of per-test-suite set-up and tear-down:
 
 ```c++
 class FooTest : public ::testing::Test {
  protected:
-  // Per-test-case set-up.
-  // Called before the first test in this test case.
+  // Per-test-suite set-up.
+  // Called before the first test in this test suite.
   // Can be omitted if not needed.
-  static void SetUpTestCase() {
+  static void SetUpTestSuite() {
     shared_resource_ = new ...;
   }
 
-  // Per-test-case tear-down.
-  // Called after the last test in this test case.
+  // Per-test-suite tear-down.
+  // Called after the last test in this test suite.
   // Can be omitted if not needed.
-  static void TearDownTestCase() {
+  static void TearDownTestSuite() {
     delete shared_resource_;
     shared_resource_ = NULL;
   }
 
   // You can define per-test set-up logic as usual.
   virtual void SetUp() { ... }
 
   // You can define per-test tear-down logic as usual.
   virtual void TearDown() { ... }
 
   // Some expensive resource shared by all tests.
   static T* shared_resource_;
 };
 
 T* FooTest::shared_resource_ = NULL;
 
 TEST_F(FooTest, Test1) {
   ... you can refer to shared_resource_ here ...
 }
 
 TEST_F(FooTest, Test2) {
   ... you can refer to shared_resource_ here ...
 }
 ```
 
-NOTE: Though the above code declares `SetUpTestCase()` protected, it may
+NOTE: Though the above code declares `SetUpTestSuite()` protected, it may
 sometimes be necessary to declare it public, such as when using it with
 `TEST_P`.
 
 **Availability**: Linux, Windows, Mac.
 
 ## Global Set-Up and Tear-Down
 
-Just as you can do set-up and tear-down at the test level and the test case
+Just as you can do set-up and tear-down at the test level and the test suite
 level, you can also do it at the test program level. Here's how.
 
 First, you subclass the `::testing::Environment` class to define a test
 environment, which knows how to set-up and tear-down:
 
 ```c++
 class Environment {
  public:
   virtual ~Environment() {}
 
   // Override this to define how to set up the environment.
   virtual void SetUp() {}
 
   // Override this to define how to tear down the environment.
   virtual void TearDown() {}
 };
 ```
 
 Then, you register an instance of your environment class with googletest by
 calling the `::testing::AddGlobalTestEnvironment()` function:
 
 ```c++
 Environment* AddGlobalTestEnvironment(Environment* env);
 ```
 
 Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
 the environment object, then runs the tests if there was no fatal failures, and
 finally calls `TearDown()` of the environment object.
 
 It's OK to register multiple environment objects. In this case, their `SetUp()`
 will be called in the order they are registered, and their `TearDown()` will be
 called in the reverse order.
 
 Note that googletest takes ownership of the registered environment objects.
 Therefore **do not delete them** by yourself.
 
 You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is called,
 probably in `main()`. If you use `gtest_main`, you need to call this before
 `main()` starts for it to take effect. One way to do this is to define a global
 variable like this:
 
 ```c++
 ::testing::Environment* const foo_env =
     ::testing::AddGlobalTestEnvironment(new FooEnvironment);
 ```
 
 However, we strongly recommend you to write your own `main()` and call
 `AddGlobalTestEnvironment()` there, as relying on initialization of global
 variables makes the code harder to read and may cause problems when you register
 multiple environments from different translation units and the environments have
 dependencies among them (remember that the compiler doesn't guarantee the order
 in which global variables from different translation units are initialized).
 
 ## Value-Parameterized Tests
 
 *Value-parameterized tests* allow you to test your code with different
 parameters without writing multiple copies of the same test. This is useful in a
 number of situations, for example:
 
 *   You have a piece of code whose behavior is affected by one or more
     command-line flags. You want to make sure your code performs correctly for
     various values of those flags.
 *   You want to test different implementations of an OO interface.
 *   You want to test your code over various inputs (a.k.a. data-driven testing).
     This feature is easy to abuse, so please exercise your good sense when doing
     it!
 
 ### How to Write Value-Parameterized Tests
 
 To write value-parameterized tests, first you should define a fixture class. It
 must be derived from both `::testing::Test` and
 `::testing::WithParamInterface<T>` (the latter is a pure interface), where `T`
 is the type of your parameter values. For convenience, you can just derive the
 fixture class from `::testing::TestWithParam<T>`, which itself is derived from
 both `::testing::Test` and `::testing::WithParamInterface<T>`. `T` can be any
 copyable type. If it's a raw pointer, you are responsible for managing the
 lifespan of the pointed values.
 
-NOTE: If your test fixture defines `SetUpTestCase()` or `TearDownTestCase()`
+NOTE: If your test fixture defines `SetUpTestSuite()` or `TearDownTestSuite()`
 they must be declared **public** rather than **protected** in order to use
 `TEST_P`.
 
 ```c++
 class FooTest :
     public ::testing::TestWithParam<const char*> {
   // You can implement all the usual fixture class members here.
   // To access the test parameter, call GetParam() from class
   // TestWithParam<T>.
 };
 
 // Or, when you want to add parameters to a pre-existing fixture class:
 class BaseTest : public ::testing::Test {
   ...
 };
 class BarTest : public BaseTest,
                 public ::testing::WithParamInterface<const char*> {
   ...
 };
 ```
 
 Then, use the `TEST_P` macro to define as many test patterns using this fixture
 as you want. The `_P` suffix is for "parameterized" or "pattern", whichever you
 prefer to think.
 
 ```c++
 TEST_P(FooTest, DoesBlah) {
   // Inside a test, access the test parameter with the GetParam() method
   // of the TestWithParam<T> class:
   EXPECT_TRUE(foo.Blah(GetParam()));
   ...
 }
 
 TEST_P(FooTest, HasBlahBlah) {
   ...
 }
 ```
 
-Finally, you can use `INSTANTIATE_TEST_CASE_P` to instantiate the test case with
+Finally, you can use `INSTANTIATE_TEST_SUITE_P` to instantiate the test suite with
 any set of parameters you want. googletest defines a number of functions for
 generating test parameters. They return what we call (surprise!) *parameter
 generators*. Here is a summary of them, which are all in the `testing`
 namespace:
 
 | Parameter Generator          | Behavior                                    |
 | ---------------------------- | ------------------------------------------- |
 | `Range(begin, end [, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1.      |
 | `Values(v1, v2, ..., vN)`    | Yields values `{v1, v2, ..., vN}`.          |
 | `ValuesIn(container)` and `ValuesIn(begin,end)`   | Yields values from a C-style array, an STL-style container, or an iterator range  `[begin, end)`. |
 | `Bool()`                     | Yields sequence `{false, true}`.            |
 | `Combine(g1, g2, ..., gN)`   | Yields all combinations (Cartesian product) as std\:\:tuples of the values generated by the `N` generators.            |
 
 For more details, see the comments at the definitions of these functions.
 
-The following statement will instantiate tests from the `FooTest` test case each
+The following statement will instantiate tests from the `FooTest` test suite each
 with parameter values `"meeny"`, `"miny"`, and `"moe"`.
 
 ```c++
-INSTANTIATE_TEST_CASE_P(InstantiationName,
+INSTANTIATE_TEST_SUITE_P(InstantiationName,
                         FooTest,
                         ::testing::Values("meeny", "miny", "moe"));
 ```
 
 NOTE: The code above must be placed at global or namespace scope, not at
 function scope.
 
 NOTE: Don't forget this step! If you do your test will silently pass, but none
-of its cases will ever run!
+of its suites will ever run!
 
 To distinguish different instances of the pattern (yes, you can instantiate it
-more than once), the first argument to `INSTANTIATE_TEST_CASE_P` is a prefix
-that will be added to the actual test case name. Remember to pick unique
+more than once), the first argument to `INSTANTIATE_TEST_SUITE_P` is a prefix
+that will be added to the actual test suite name. Remember to pick unique
 prefixes for different instantiations. The tests from the instantiation above
 will have these names:
 
 *   `InstantiationName/FooTest.DoesBlah/0` for `"meeny"`
 *   `InstantiationName/FooTest.DoesBlah/1` for `"miny"`
 *   `InstantiationName/FooTest.DoesBlah/2` for `"moe"`
 *   `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"`
 *   `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"`
 *   `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"`
 
 You can use these names in [`--gtest_filter`](#running-a-subset-of-the-tests).
 
 This statement will instantiate all tests from `FooTest` again, each with
 parameter values `"cat"` and `"dog"`:
 
 ```c++
 const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest,
+INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest,
                         ::testing::ValuesIn(pets));
 ```
 
 The tests from the instantiation above will have these names:
 
 *   `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"`
 *   `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"`
 *   `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"`
 *   `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"`
 
-Please note that `INSTANTIATE_TEST_CASE_P` will instantiate *all* tests in the
-given test case, whether their definitions come before or *after* the
-`INSTANTIATE_TEST_CASE_P` statement.
+Please note that `INSTANTIATE_TEST_SUITE_P` will instantiate *all* tests in the
+given test suite, whether their definitions come before or *after* the
+`INSTANTIATE_TEST_SUITE_P` statement.
 
 You can see sample7_unittest.cc and sample8_unittest.cc for more examples.
 
 **Availability**: Linux, Windows (requires MSVC 8.0 or above), Mac
 
 ### Creating Value-Parameterized Abstract Tests
 
 In the above, we define and instantiate `FooTest` in the *same* source file.
 Sometimes you may want to define value-parameterized tests in a library and let
 other people instantiate them later. This pattern is known as *abstract tests*.
 As an example of its application, when you are designing an interface you can
 write a standard suite of abstract tests (perhaps using a factory function as
 the test parameter) that all implementations of the interface are expected to
 pass. When someone implements the interface, they can instantiate your suite to
 get all the interface-conformance tests for free.
 
 To define abstract tests, you should organize your code like this:
 
 1.  Put the definition of the parameterized test fixture class (e.g. `FooTest`)
     in a header file, say `foo_param_test.h`. Think of this as *declaring* your
     abstract tests.
 1.  Put the `TEST_P` definitions in `foo_param_test.cc`, which includes
     `foo_param_test.h`. Think of this as *implementing* your abstract tests.
 
 Once they are defined, you can instantiate them by including `foo_param_test.h`,
-invoking `INSTANTIATE_TEST_CASE_P()`, and depending on the library target that
-contains `foo_param_test.cc`. You can instantiate the same abstract test case
+invoking `INSTANTIATE_TEST_SUITE_P()`, and depending on the library target that
+contains `foo_param_test.cc`. You can instantiate the same abstract test suite
 multiple times, possibly in different source files.
 
 ### Specifying Names for Value-Parameterized Test Parameters
 
-The optional last argument to `INSTANTIATE_TEST_CASE_P()` allows the user to
+The optional last argument to `INSTANTIATE_TEST_SUITE_P()` allows the user to
 specify a function or functor that generates custom test name suffixes based on
 the test parameters. The function should accept one argument of type
 `testing::TestParamInfo<class ParamType>`, and return `std::string`.
 
 `testing::PrintToStringParamName` is a builtin test suffix generator that
 returns the value of `testing::PrintToString(GetParam())`. It does not work for
 `std::string` or C strings.
 
 NOTE: test names must be non-empty, unique, and may only contain ASCII
 alphanumeric characters. In particular, they [should not contain
-underscores](https://github.com/google/googletest/blob/master/googletest/docs/faq.md#why-should-test-case-names-and-test-names-not-contain-underscore).
+underscores](https://github.com/google/googletest/blob/master/googletest/docs/faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore).
 
 ```c++
-class MyTestCase : public testing::TestWithParam<int> {};
+class MyTestsuite : public testing::TestWithParam<int> {};
 
-TEST_P(MyTestCase, MyTest)
+TEST_P(MyTestsuite, MyTest)
 {
   std::cout << "Example Test Param: " << GetParam() << std::endl;
 }
 
-INSTANTIATE_TEST_CASE_P(MyGroup, MyTestCase, testing::Range(0, 10),
+INSTANTIATE_TEST_SUITE_P(MyGroup, MyTestsuite, testing::Range(0, 10),
                         testing::PrintToStringParamName());
 ```
 
 ## Typed Tests</id>
 
 Suppose you have multiple implementations of the same interface and want to make
 sure that all of them satisfy some common requirements. Or, you may have defined
 several types that are supposed to conform to the same "concept" and you want to
 verify it. In both cases, you want the same test logic repeated for different
 types.
 
 While you can write one `TEST` or `TEST_F` for each type you want to test (and
 you may even factor the test logic into a function template that you invoke from
 the `TEST`), it's tedious and doesn't scale: if you want `m` tests over `n`
 types, you'll end up writing `m*n` `TEST`s.
 
 *Typed tests* allow you to repeat the same test logic over a list of types. You
 only need to write the test logic once, although you must know the type list
 when writing typed tests. Here's how you do it:
 
 First, define a fixture class template. It should be parameterized by a type.
 Remember to derive it from `::testing::Test`:
 
 ```c++
 template <typename T>
 class FooTest : public ::testing::Test {
  public:
   ...
   typedef std::list<T> List;
   static T shared_;
   T value_;
 };
 ```
 
-Next, associate a list of types with the test case, which will be repeated for
+Next, associate a list of types with the test suite, which will be repeated for
 each type in the list:
 
 ```c++
 using MyTypes = ::testing::Types<char, int, unsigned int>;
-TYPED_TEST_CASE(FooTest, MyTypes);
+TYPED_TEST_SUITE(FooTest, MyTypes);
 ```
 
-The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_CASE`
+The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_SUITE`
 macro to parse correctly. Otherwise the compiler will think that each comma in
 the type list introduces a new macro argument.
 
 Then, use `TYPED_TEST()` instead of `TEST_F()` to define a typed test for this
-test case. You can repeat this as many times as you want:
+test suite. You can repeat this as many times as you want:
 
 ```c++
 TYPED_TEST(FooTest, DoesBlah) {
   // Inside a test, refer to the special name TypeParam to get the type
   // parameter.  Since we are inside a derived class template, C++ requires
   // us to visit the members of FooTest via 'this'.
   TypeParam n = this->value_;
 
   // To visit static members of the fixture, add the 'TestFixture::'
   // prefix.
   n += TestFixture::shared_;
 
   // To refer to typedefs in the fixture, add the 'typename TestFixture::'
   // prefix.  The 'typename' is required to satisfy the compiler.
   typename TestFixture::List values;
 
   values.push_back(n);
   ...
 }
 
 TYPED_TEST(FooTest, HasPropertyA) { ... }
 ```
 
 You can see sample6_unittest.cc
 
 **Availability**: Linux, Windows (requires MSVC 8.0 or above), Mac
 
 ## Type-Parameterized Tests
 
 *Type-parameterized tests* are like typed tests, except that they don't require
 you to know the list of types ahead of time. Instead, you can define the test
 logic first and instantiate it with different type lists later. You can even
 instantiate it more than once in the same program.
 
 If you are designing an interface or concept, you can define a suite of
 type-parameterized tests to verify properties that any valid implementation of
 the interface/concept should have. Then, the author of each implementation can
 just instantiate the test suite with their type to verify that it conforms to
 the requirements, without having to write similar tests repeatedly. Here's an
 example:
 
 First, define a fixture class template, as we did with typed tests:
 
 ```c++
 template <typename T>
 class FooTest : public ::testing::Test {
   ...
 };
 ```
 
-Next, declare that you will define a type-parameterized test case:
+Next, declare that you will define a type-parameterized test suite:
 
 ```c++
-TYPED_TEST_CASE_P(FooTest);
+TYPED_TEST_SUITE_P(FooTest);
 ```
 
 Then, use `TYPED_TEST_P()` to define a type-parameterized test. You can repeat
 this as many times as you want:
 
 ```c++
 TYPED_TEST_P(FooTest, DoesBlah) {
   // Inside a test, refer to TypeParam to get the type parameter.
   TypeParam n = 0;
   ...
 }
 
 TYPED_TEST_P(FooTest, HasPropertyA) { ... }
 ```
 
 Now the tricky part: you need to register all test patterns using the
-`REGISTER_TYPED_TEST_CASE_P` macro before you can instantiate them. The first
-argument of the macro is the test case name; the rest are the names of the tests
-in this test case:
+`REGISTER_TYPED_TEST_SUITE_P` macro before you can instantiate them. The first
+argument of the macro is the test suite name; the rest are the names of the tests
+in this test suite:
 
 ```c++
-REGISTER_TYPED_TEST_CASE_P(FooTest,
+REGISTER_TYPED_TEST_SUITE_P(FooTest,
                            DoesBlah, HasPropertyA);
 ```
 
 Finally, you are free to instantiate the pattern with the types you want. If you
 put the above code in a header file, you can `#include` it in multiple C++
 source files and instantiate it multiple times.
 
 ```c++
 typedef ::testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
 ```
 
 To distinguish different instances of the pattern, the first argument to the
-`INSTANTIATE_TYPED_TEST_CASE_P` macro is a prefix that will be added to the
-actual test case name. Remember to pick unique prefixes for different instances.
+`INSTANTIATE_TYPED_TEST_SUITE_P` macro is a prefix that will be added to the
+actual test suite name. Remember to pick unique prefixes for different instances.
 
 In the special case where the type list contains only one type, you can write
 that type directly without `::testing::Types<...>`, like this:
 
 ```c++
-INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
 ```
 
 You can see `sample6_unittest.cc` for a complete example.
 
 **Availability**: Linux, Windows (requires MSVC 8.0 or above), Mac
 
 ## Testing Private Code
 
 If you change your software's internal implementation, your tests should not
 break as long as the change is not observable by users. Therefore, **per the
 black-box testing principle, most of the time you should test your code through
 its public interfaces.**
 
 **If you still find yourself needing to test internal implementation code,
 consider if there's a better design.** The desire to test internal
 implementation is often a sign that the class is doing too much. Consider
 extracting an implementation class, and testing it. Then use that implementation
 class in the original class.
 
 If you absolutely have to test non-public interface code though, you can. There
 are two cases to consider:
 
 *   Static functions ( *not* the same as static member functions!) or unnamed
     namespaces, and
 *   Private or protected class members
 
 To test them, we use the following special techniques:
 
 *   Both static functions and definitions/declarations in an unnamed namespace
     are only visible within the same translation unit. To test them, you can
     `#include` the entire `.cc` file being tested in your `*_test.cc` file.
     (including `.cc` files is not a good way to reuse code - you should not do
     this in production code!)
 
     However, a better approach is to move the private code into the
     `foo::internal` namespace, where `foo` is the namespace your project
     normally uses, and put the private declarations in a `*-internal.h` file.
     Your production `.cc` files and your tests are allowed to include this
     internal header, but your clients are not. This way, you can fully test your
     internal implementation without leaking it to your clients.
 
 *   Private class members are only accessible from within the class or by
     friends. To access a class' private members, you can declare your test
     fixture as a friend to the class and define accessors in your fixture. Tests
     using the fixture can then access the private members of your production
     class via the accessors in the fixture. Note that even though your fixture
     is a friend to your production class, your tests are not automatically
     friends to it, as they are technically defined in sub-classes of the
     fixture.
 
     Another way to test private members is to refactor them into an
     implementation class, which is then declared in a `*-internal.h` file. Your
     clients aren't allowed to include this header but your tests can. Such is
     called the
     [Pimpl](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/the-c-pimpl-r1794/)
     (Private Implementation) idiom.
 
     Or, you can declare an individual test as a friend of your class by adding
     this line in the class body:
 
     ```c++
-        FRIEND_TEST(TestCaseName, TestName);
+        FRIEND_TEST(TestsuiteName, TestName);
     ```
 
     For example,
 
     ```c++
     // foo.h
 
     #include "gtest/gtest_prod.h"
 
     class Foo {
       ...
     private:
       FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
 
       int Bar(void* x);
     };
 
     // foo_test.cc
     ...
     TEST(FooTest, BarReturnsZeroOnNull) {
       Foo foo;
       EXPECT_EQ(0, foo.Bar(NULL));  // Uses Foo's private member Bar().
     }
     ```
 
     Pay special attention when your class is defined in a namespace, as you
     should define your test fixtures and tests in the same namespace if you want
     them to be friends of your class. For example, if the code to be tested
     looks like:
 
     ```c++
     namespace my_namespace {
 
     class Foo {
       friend class FooTest;
       FRIEND_TEST(FooTest, Bar);
       FRIEND_TEST(FooTest, Baz);
       ... definition of the class Foo ...
     };
 
     }  // namespace my_namespace
     ```
 
     Your test code should be something like:
 
     ```c++
     namespace my_namespace {
 
     class FooTest : public ::testing::Test {
      protected:
       ...
     };
 
     TEST_F(FooTest, Bar) { ... }
     TEST_F(FooTest, Baz) { ... }
 
     }  // namespace my_namespace
     ```
 
 
 ## "Catching" Failures
 
 If you are building a testing utility on top of googletest, you'll want to test
 your utility. What framework would you use to test it? googletest, of course.
 
 The challenge is to verify that your testing utility reports failures correctly.
 In frameworks that report a failure by throwing an exception, you could catch
 the exception and assert on it. But googletest doesn't use exceptions, so how do
 we test that a piece of code generates an expected failure?
 
 gunit-spi.h contains some constructs to do this. After #including this header,
 you can use
 
 ```c++
   EXPECT_FATAL_FAILURE(statement, substring);
 ```
 
 to assert that `statement` generates a fatal (e.g. `ASSERT_*`) failure in the
 current thread whose message contains the given `substring`, or use
 
 ```c++
   EXPECT_NONFATAL_FAILURE(statement, substring);
 ```
 
 if you are expecting a non-fatal (e.g. `EXPECT_*`) failure.
 
 Only failures in the current thread are checked to determine the result of this
 type of expectations. If `statement` creates new threads, failures in these
 threads are also ignored. If you want to catch failures in other threads as
 well, use one of the following macros instead:
 
 ```c++
   EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substring);
   EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substring);
 ```
 
 NOTE: Assertions from multiple threads are currently not supported on Windows.
 
 For technical reasons, there are some caveats:
 
 1.  You cannot stream a failure message to either macro.
 
 1.  `statement` in `EXPECT_FATAL_FAILURE{_ON_ALL_THREADS}()` cannot reference
     local non-static variables or non-static members of `this` object.
 
 1.  `statement` in `EXPECT_FATAL_FAILURE{_ON_ALL_THREADS}()()` cannot return a
     value.
 
 
 ## Getting the Current Test's Name
 
 Sometimes a function may need to know the name of the currently running test.
 For example, you may be using the `SetUp()` method of your test fixture to set
 the golden file name based on which test is running. The `::testing::TestInfo`
 class has this information:
 
 ```c++
 namespace testing {
 
 class TestInfo {
  public:
-  // Returns the test case name and the test name, respectively.
+  // Returns the test suite name and the test name, respectively.
   //
   // Do NOT delete or free the return value - it's managed by the
   // TestInfo class.
-  const char* test_case_name() const;
+  const char* test_suite_name() const;
   const char* name() const;
 };
 
 }
 ```
 
 To obtain a `TestInfo` object for the currently running test, call
 `current_test_info()` on the `UnitTest` singleton object:
 
 ```c++
   // Gets information about the currently running test.
   // Do NOT delete the returned object - it's managed by the UnitTest class.
   const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
 
 
-  printf("We are in test %s of test case %s.\n",
+  printf("We are in test %s of test suite %s.\n",
          test_info->name(),
-         test_info->test_case_name());
+         test_info->test_suite_name());
 ```
 
 `current_test_info()` returns a null pointer if no test is running. In
-particular, you cannot find the test case name in `TestCaseSetUp()`,
-`TestCaseTearDown()` (where you know the test case name implicitly), or
+particular, you cannot find the test suite name in `TestsuiteSetUp()`,
+`TestsuiteTearDown()` (where you know the test suite name implicitly), or
 functions called from them.
 
 **Availability**: Linux, Windows, Mac.
 
 ## Extending googletest by Handling Test Events
 
 googletest provides an **event listener API** to let you receive notifications
 about the progress of a test program and test failures. The events you can
-listen to include the start and end of the test program, a test case, or a test
+listen to include the start and end of the test program, a test suite, or a test
 method, among others. You may use this API to augment or replace the standard
 console output, replace the XML output, or provide a completely different form
 of output, such as a GUI or a database. You can also use test events as
 checkpoints to implement a resource leak checker, for example.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Defining Event Listeners
 
 To define a event listener, you subclass either testing::TestEventListener or
 testing::EmptyTestEventListener The former is an (abstract) interface, where
 *each pure virtual method can be overridden to handle a test event* (For
 example, when a test starts, the `OnTestStart()` method will be called.). The
 latter provides an empty implementation of all methods in the interface, such
 that a subclass only needs to override the methods it cares about.
 
 When an event is fired, its context is passed to the handler function as an
 argument. The following argument types are used:
 
 *   UnitTest reflects the state of the entire test program,
-*   TestCase has information about a test case, which can contain one or more
+*   Testsuite has information about a test suite, which can contain one or more
     tests,
 *   TestInfo contains the state of a test, and
 *   TestPartResult represents the result of a test assertion.
 
 An event handler function can examine the argument it receives to find out
 interesting information about the event and the test program's state.
 
 Here's an example:
 
 ```c++
   class MinimalistPrinter : public ::testing::EmptyTestEventListener {
     // Called before a test starts.
     virtual void OnTestStart(const ::testing::TestInfo& test_info) {
       printf("*** Test %s.%s starting.\n",
-             test_info.test_case_name(), test_info.name());
+             test_info.test_suite_name(), test_info.name());
     }
 
     // Called after a failed assertion or a SUCCESS().
     virtual void OnTestPartResult(const ::testing::TestPartResult& test_part_result) {
       printf("%s in %s:%d\n%s\n",
              test_part_result.failed() ? "*** Failure" : "Success",
              test_part_result.file_name(),
              test_part_result.line_number(),
              test_part_result.summary());
     }
 
     // Called after a test ends.
     virtual void OnTestEnd(const ::testing::TestInfo& test_info) {
       printf("*** Test %s.%s ending.\n",
-             test_info.test_case_name(), test_info.name());
+             test_info.test_suite_name(), test_info.name());
     }
   };
 ```
 
 ### Using Event Listeners
 
 To use the event listener you have defined, add an instance of it to the
 googletest event listener list (represented by class TestEventListeners - note
 the "s" at the end of the name) in your `main()` function, before calling
 `RUN_ALL_TESTS()`:
 
 ```c++
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   // Gets hold of the event listener list.
   ::testing::TestEventListeners& listeners =
         ::testing::UnitTest::GetInstance()->listeners();
   // Adds a listener to the end.  googletest takes the ownership.
   listeners.Append(new MinimalistPrinter);
   return RUN_ALL_TESTS();
 }
 ```
 
 There's only one problem: the default test result printer is still in effect, so
 its output will mingle with the output from your minimalist printer. To suppress
 the default printer, just release it from the event listener list and delete it.
 You can do so by adding one line:
 
 ```c++
   ...
   delete listeners.Release(listeners.default_result_printer());
   listeners.Append(new MinimalistPrinter);
   return RUN_ALL_TESTS();
 ```
 
 Now, sit back and enjoy a completely different output from your tests. For more
 details, you can read this sample9_unittest.cc
 
 You may append more than one listener to the list. When an `On*Start()` or
 `OnTestPartResult()` event is fired, the listeners will receive it in the order
 they appear in the list (since new listeners are added to the end of the list,
 the default text printer and the default XML generator will receive the event
 first). An `On*End()` event will be received by the listeners in the *reverse*
 order. This allows output by listeners added later to be framed by output from
 listeners added earlier.
 
 ### Generating Failures in Listeners
 
 You may use failure-raising macros (`EXPECT_*()`, `ASSERT_*()`, `FAIL()`, etc)
 when processing an event. There are some restrictions:
 
 1.  You cannot generate any failure in `OnTestPartResult()` (otherwise it will
     cause `OnTestPartResult()` to be called recursively).
 1.  A listener that handles `OnTestPartResult()` is not allowed to generate any
     failure.
 
 When you add listeners to the listener list, you should put listeners that
 handle `OnTestPartResult()` *before* listeners that can generate failures. This
 ensures that failures generated by the latter are attributed to the right test
 by the former.
 
 We have a sample of failure-raising listener sample10_unittest.cc
 
 ## Running Test Programs: Advanced Options
 
 googletest test programs are ordinary executables. Once built, you can run them
 directly and affect their behavior via the following environment variables
 and/or command line flags. For the flags to work, your programs must call
 `::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
 
 To see a list of supported flags and their usage, please run your test program
 with the `--help` flag. You can also use `-h`, `-?`, or `/?` for short.
 
 If an option is specified both by an environment variable and by a flag, the
 latter takes precedence.
 
 ### Selecting Tests
 
 #### Listing Test Names
 
 Sometimes it is necessary to list the available tests in a program before
 running them so that a filter may be applied if needed. Including the flag
 `--gtest_list_tests` overrides all other flags and lists tests in the following
 format:
 
 ```none
-TestCase1.
+Testsuite1.
   TestName1
   TestName2
-TestCase2.
+Testsuite2.
   TestName
 ```
 
 None of the tests listed are actually run if the flag is provided. There is no
 corresponding environment variable for this flag.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Running a Subset of the Tests
 
 By default, a googletest program runs all tests the user has defined. Sometimes,
 you want to run only a subset of the tests (e.g. for debugging or quickly
 verifying a change). If you set the `GTEST_FILTER` environment variable or the
 `--gtest_filter` flag to a filter string, googletest will only run the tests
-whose full names (in the form of `TestCaseName.TestName`) match the filter.
+whose full names (in the form of `TestsuiteName.TestName`) match the filter.
 
 The format of a filter is a '`:`'-separated list of wildcard patterns (called
 the *positive patterns*) optionally followed by a '`-`' and another
 '`:`'-separated pattern list (called the *negative patterns*). A test matches
 the filter if and only if it matches any of the positive patterns but does not
 match any of the negative patterns.
 
 A pattern may contain `'*'` (matches any string) or `'?'` (matches any single
 character). For convenience, the filter
 
 `'*-NegativePatterns'` can be also written as `'-NegativePatterns'`.
 
 For example:
 
 *   `./foo_test` Has no flag, and thus runs all its tests.
 *   `./foo_test --gtest_filter=*` Also runs everything, due to the single
     match-everything `*` value.
-*   `./foo_test --gtest_filter=FooTest.*` Runs everything in test case `FooTest`
+*   `./foo_test --gtest_filter=FooTest.*` Runs everything in test suite `FooTest`
     .
 *   `./foo_test --gtest_filter=*Null*:*Constructor*` Runs any test whose full
     name contains either `"Null"` or `"Constructor"` .
 *   `./foo_test --gtest_filter=-*DeathTest.*` Runs all non-death tests.
 *   `./foo_test --gtest_filter=FooTest.*-FooTest.Bar` Runs everything in test
-    case `FooTest` except `FooTest.Bar`.
+    suite `FooTest` except `FooTest.Bar`.
 *   `./foo_test --gtest_filter=FooTest.*:BarTest.*-FooTest.Bar:BarTest.Foo` Runs
-    everything in test case `FooTest` except `FooTest.Bar` and everything in
-    test case `BarTest` except `BarTest.Foo`.
-    
+    everything in test suite `FooTest` except `FooTest.Bar` and everything in
+    test suite `BarTest` except `BarTest.Foo`.
+
 #### Temporarily Disabling Tests
 
 If you have a broken test that you cannot fix right away, you can add the
 `DISABLED_` prefix to its name. This will exclude it from execution. This is
 better than commenting out the code or using `#if 0`, as disabled tests are
 still compiled (and thus won't rot).
 
-If you need to disable all tests in a test case, you can either add `DISABLED_`
+If you need to disable all tests in a test suite, you can either add `DISABLED_`
 to the front of the name of each test, or alternatively add it to the front of
-the test case name.
+the test suite name.
 
 For example, the following tests won't be run by googletest, even though they
 will still be compiled:
 
 ```c++
 // Tests that Foo does Abc.
 TEST(FooTest, DISABLED_DoesAbc) { ... }
 
 class DISABLED_BarTest : public ::testing::Test { ... };
 
 // Tests that Bar does Xyz.
 TEST_F(DISABLED_BarTest, DoesXyz) { ... }
 ```
 
 NOTE: This feature should only be used for temporary pain-relief. You still have
 to fix the disabled tests at a later date. As a reminder, googletest will print
 a banner warning you if a test program contains any disabled tests.
 
 TIP: You can easily count the number of disabled tests you have using `gsearch`
 and/or `grep`. This number can be used as a metric for improving your test
 quality.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Temporarily Enabling Disabled Tests
 
 To include disabled tests in test execution, just invoke the test program with
 the `--gtest_also_run_disabled_tests` flag or set the
 `GTEST_ALSO_RUN_DISABLED_TESTS` environment variable to a value other than `0`.
 You can combine this with the `--gtest_filter` flag to further select which
 disabled tests to run.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Repeating the Tests
 
 Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
 will fail only 1% of the time, making it rather hard to reproduce the bug under
 a debugger. This can be a major source of frustration.
 
 The `--gtest_repeat` flag allows you to repeat all (or selected) test methods in
 a program many times. Hopefully, a flaky test will eventually fail and give you
 a chance to debug. Here's how to use it:
 
 ```none
 $ foo_test --gtest_repeat=1000
 Repeat foo_test 1000 times and don't stop at failures.
 
 $ foo_test --gtest_repeat=-1
 A negative count means repeating forever.
 
 $ foo_test --gtest_repeat=1000 --gtest_break_on_failure
 Repeat foo_test 1000 times, stopping at the first failure.  This
 is especially useful when running under a debugger: when the test
 fails, it will drop into the debugger and you can then inspect
 variables and stacks.
 
 $ foo_test --gtest_repeat=1000 --gtest_filter=FooBar.*
 Repeat the tests whose name matches the filter 1000 times.
 ```
 
 If your test program contains [global set-up/tear-down](#global-set-up-and-tear-down) code, it
 will be repeated in each iteration as well, as the flakiness may be in it. You
 can also specify the repeat count by setting the `GTEST_REPEAT` environment
 variable.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Shuffling the Tests
 
 You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
 environment variable to `1`) to run the tests in a program in a random order.
 This helps to reveal bad dependencies between tests.
 
 By default, googletest uses a random seed calculated from the current time.
 Therefore you'll get a different order every time. The console output includes
 the random seed value, such that you can reproduce an order-related test failure
 later. To specify the random seed explicitly, use the `--gtest_random_seed=SEED`
 flag (or set the `GTEST_RANDOM_SEED` environment variable), where `SEED` is an
 integer in the range [0, 99999]. The seed value 0 is special: it tells
 googletest to do the default behavior of calculating the seed from the current
 time.
 
 If you combine this with `--gtest_repeat=N`, googletest will pick a different
 random seed and re-shuffle the tests in each iteration.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Controlling Test Output
 
 #### Colored Terminal Output
 
 googletest can use colors in its terminal output to make it easier to spot the
 important information:
 
 ...<br/>
 <span style="color:green">[----------]<span style="color:black"> 1 test from FooTest<br/>
 <span style="color:green">[ RUN      ]<span style="color:black"> FooTest.DoesAbc<br/>
 <span style="color:green">[       OK ]<span style="color:black"> FooTest.DoesAbc<br/>
 <span style="color:green">[----------]<span style="color:black"> 2 tests from BarTest<br/>
 <span style="color:green">[ RUN      ]<span style="color:black"> BarTest.HasXyzProperty<br/>
 <span style="color:green">[       OK ]<span style="color:black"> BarTest.HasXyzProperty<br/>
 <span style="color:green">[ RUN      ]<span style="color:black"> BarTest.ReturnsTrueOnSuccess<br/>
 ... some error messages ...<br/>
 <span   style="color:red">[  FAILED  ] <span style="color:black">BarTest.ReturnsTrueOnSuccess<br/>
 ...<br/>
-<span style="color:green">[==========]<span style="color:black"> 30 tests from 14 test cases ran.<br/>
+<span style="color:green">[==========]<span style="color:black"> 30 tests from 14 test suites ran.<br/>
 <span style="color:green">[  PASSED  ]<span style="color:black"> 28 tests.<br/>
 <span style="color:red">[  FAILED  ]<span style="color:black"> 2 tests, listed below:<br/>
 <span style="color:red">[  FAILED  ]<span style="color:black"> BarTest.ReturnsTrueOnSuccess<br/>
 <span style="color:red">[  FAILED  ]<span style="color:black"> AnotherTest.DoesXyz<br/>
   2 FAILED TESTS
 
 You can set the `GTEST_COLOR` environment variable or the `--gtest_color`
 command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
 disable colors, or let googletest decide. When the value is `auto`, googletest
 will use colors if and only if the output goes to a terminal and (on non-Windows
 platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`.
 
  **Availability**: Linux, Windows, Mac.
 
 #### Suppressing the Elapsed Time
 
 By default, googletest prints the time it takes to run each test. To disable
 that, run the test program with the `--gtest_print_time=0` command line flag, or
 set the GTEST_PRINT_TIME environment variable to `0`.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Suppressing UTF-8 Text Output
 
 In case of assertion failures, googletest prints expected and actual values of
 type `string` both as hex-encoded strings as well as in readable UTF-8 text if
 they contain valid non-ASCII UTF-8 characters. If you want to suppress the UTF-8
 text because, for example, you don't have an UTF-8 compatible output medium, run
 the test program with `--gtest_print_utf8=0` or set the `GTEST_PRINT_UTF8`
 environment variable to `0`.
 
 **Availability**: Linux, Windows, Mac.
 
 
 #### Generating an XML Report
 
 googletest can emit a detailed XML report to a file in addition to its normal
 textual output. The report contains the duration of each test, and thus can help
 you identify slow tests. The report is also used by the http://unittest
 dashboard to show per-test-method error messages.
 
 To generate the XML report, set the `GTEST_OUTPUT` environment variable or the
 `--gtest_output` flag to the string `"xml:path_to_output_file"`, which will
 create the file at the given location. You can also just use the string `"xml"`,
 in which case the output can be found in the `test_detail.xml` file in the
 current directory.
 
 If you specify a directory (for example, `"xml:output/directory/"` on Linux or
 `"xml:output\directory\"` on Windows), googletest will create the XML file in
 that directory, named after the test executable (e.g. `foo_test.xml` for test
 program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
 over from a previous run), googletest will pick a different name (e.g.
 `foo_test_1.xml`) to avoid overwriting it.
 
 
 The report is based on the `junitreport` Ant task. Since that format was
 originally intended for Java, a little interpretation is required to make it
 apply to googletest tests, as shown here:
 
 ```xml
 <testsuites name="AllTests" ...>
-  <testsuite name="test_case_name" ...>
+  <testsuite name="test_suite_name" ...>
     <testcase    name="test_name" ...>
       <failure message="..."/>
       <failure message="..."/>
       <failure message="..."/>
     </testcase>
   </testsuite>
 </testsuites>
 ```
 
 *   The root `<testsuites>` element corresponds to the entire test program.
-*   `<testsuite>` elements correspond to googletest test cases.
+*   `<testsuite>` elements correspond to googletest test suites.
 *   `<testcase>` elements correspond to googletest test functions.
 
 For instance, the following program
 
 ```c++
 TEST(MathTest, Addition) { ... }
 TEST(MathTest, Subtraction) { ... }
 TEST(LogicTest, NonContradiction) { ... }
 ```
 
 could generate this report:
 
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites tests="3" failures="1" errors="0" time="0.035" timestamp="2011-10-31T18:52:42" name="AllTests">
   <testsuite name="MathTest" tests="2" failures="1" errors="0" time="0.015">
     <testcase name="Addition" status="run" time="0.007" classname="">
       <failure message="Value of: add(1, 1)&#x0A;  Actual: 3&#x0A;Expected: 2" type="">...</failure>
       <failure message="Value of: add(1, -1)&#x0A;  Actual: 1&#x0A;Expected: 0" type="">...</failure>
     </testcase>
     <testcase name="Subtraction" status="run" time="0.005" classname="">
     </testcase>
   </testsuite>
   <testsuite name="LogicTest" tests="1" failures="0" errors="0" time="0.005">
     <testcase name="NonContradiction" status="run" time="0.005" classname="">
     </testcase>
   </testsuite>
 </testsuites>
 ```
 
 Things to note:
 
 *   The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how
-    many test functions the googletest program or test case contains, while the
+    many test functions the googletest program or test suite contains, while the
     `failures` attribute tells how many of them failed.
 
-*   The `time` attribute expresses the duration of the test, test case, or
+*   The `time` attribute expresses the duration of the test, test suite, or
     entire test program in seconds.
 
 *   The `timestamp` attribute records the local date and time of the test
     execution.
 
 *   Each `<failure>` element corresponds to a single failed googletest
     assertion.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Generating an JSON Report
 
 googletest can also emit a JSON report as an alternative format to XML. To
 generate the JSON report, set the `GTEST_OUTPUT` environment variable or the
 `--gtest_output` flag to the string `"json:path_to_output_file"`, which will
 create the file at the given location. You can also just use the string
 `"json"`, in which case the output can be found in the `test_detail.json` file
 in the current directory.
 
 The report format conforms to the following JSON Schema:
 
 ```json
 {
   "$schema": "http://json-schema.org/schema#",
   "type": "object",
   "definitions": {
-    "TestCase": {
+    "Testsuite": {
       "type": "object",
       "properties": {
         "name": { "type": "string" },
         "tests": { "type": "integer" },
         "failures": { "type": "integer" },
         "disabled": { "type": "integer" },
         "time": { "type": "string" },
         "testsuite": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/TestInfo"
           }
         }
       }
     },
     "TestInfo": {
       "type": "object",
       "properties": {
         "name": { "type": "string" },
         "status": {
           "type": "string",
           "enum": ["RUN", "NOTRUN"]
         },
         "time": { "type": "string" },
         "classname": { "type": "string" },
         "failures": {
           "type": "array",
           "items": {
             "$ref": "#/definitions/Failure"
           }
         }
       }
     },
     "Failure": {
       "type": "object",
       "properties": {
         "failures": { "type": "string" },
         "type": { "type": "string" }
       }
     }
   },
   "properties": {
     "tests": { "type": "integer" },
     "failures": { "type": "integer" },
     "disabled": { "type": "integer" },
     "errors": { "type": "integer" },
     "timestamp": {
       "type": "string",
       "format": "date-time"
     },
     "time": { "type": "string" },
     "name": { "type": "string" },
     "testsuites": {
       "type": "array",
       "items": {
-        "$ref": "#/definitions/TestCase"
+        "$ref": "#/definitions/Testsuite"
       }
     }
   }
 }
 ```
 
 The report uses the format that conforms to the following Proto3 using the [JSON
 encoding](https://developers.google.com/protocol-buffers/docs/proto3#json):
 
 ```proto
 syntax = "proto3";
 
 package googletest;
 
 import "google/protobuf/timestamp.proto";
 import "google/protobuf/duration.proto";
 
 message UnitTest {
   int32 tests = 1;
   int32 failures = 2;
   int32 disabled = 3;
   int32 errors = 4;
   google.protobuf.Timestamp timestamp = 5;
   google.protobuf.Duration time = 6;
   string name = 7;
-  repeated TestCase testsuites = 8;
+  repeated Testsuite testsuites = 8;
 }
 
 message TestCase {
   string name = 1;
   int32 tests = 2;
   int32 failures = 3;
   int32 disabled = 4;
   int32 errors = 5;
   google.protobuf.Duration time = 6;
   repeated TestInfo testsuite = 7;
 }
 
 message TestInfo {
   string name = 1;
   enum Status {
     RUN = 0;
     NOTRUN = 1;
   }
   Status status = 2;
   google.protobuf.Duration time = 3;
   string classname = 4;
   message Failure {
     string failures = 1;
     string type = 2;
   }
   repeated Failure failures = 5;
 }
 ```
 
 For instance, the following program
 
 ```c++
 TEST(MathTest, Addition) { ... }
 TEST(MathTest, Subtraction) { ... }
 TEST(LogicTest, NonContradiction) { ... }
 ```
 
 could generate this report:
 
 ```json
 {
   "tests": 3,
   "failures": 1,
   "errors": 0,
   "time": "0.035s",
   "timestamp": "2011-10-31T18:52:42Z"
   "name": "AllTests",
   "testsuites": [
     {
       "name": "MathTest",
       "tests": 2,
       "failures": 1,
       "errors": 0,
       "time": "0.015s",
       "testsuite": [
         {
           "name": "Addition",
           "status": "RUN",
           "time": "0.007s",
           "classname": "",
           "failures": [
             {
               "message": "Value of: add(1, 1)\x0A  Actual: 3\x0AExpected: 2",
               "type": ""
             },
             {
               "message": "Value of: add(1, -1)\x0A  Actual: 1\x0AExpected: 0",
               "type": ""
             }
           ]
         },
         {
           "name": "Subtraction",
           "status": "RUN",
           "time": "0.005s",
           "classname": ""
         }
       ]
     }
     {
       "name": "LogicTest",
       "tests": 1,
       "failures": 0,
       "errors": 0,
       "time": "0.005s",
       "testsuite": [
         {
           "name": "NonContradiction",
           "status": "RUN",
           "time": "0.005s",
           "classname": ""
         }
       ]
     }
   ]
 }
 ```
 
 IMPORTANT: The exact format of the JSON document is subject to change.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Controlling How Failures Are Reported
 
 #### Turning Assertion Failures into Break-Points
 
 When running test programs under a debugger, it's very convenient if the
 debugger can catch an assertion failure and automatically drop into interactive
 mode. googletest's *break-on-failure* mode supports this behavior.
 
 To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
 other than `0` . Alternatively, you can use the `--gtest_break_on_failure`
 command line flag.
 
 **Availability**: Linux, Windows, Mac.
 
 #### Disabling Catching Test-Thrown Exceptions
 
 googletest can be used either with or without exceptions enabled. If a test
 throws a C++ exception or (on Windows) a structured exception (SEH), by default
 googletest catches it, reports it as a test failure, and continues with the next
 test method. This maximizes the coverage of a test run. Also, on Windows an
 uncaught exception will cause a pop-up window, so catching the exceptions allows
 you to run the tests automatically.
 
 When debugging the test failures, however, you may instead want the exceptions
 to be handled by the debugger, such that you can examine the call stack when an
 exception is thrown. To achieve that, set the `GTEST_CATCH_EXCEPTIONS`
 environment variable to `0`, or use the `--gtest_catch_exceptions=0` flag when
 running the tests.
 
 **Availability**: Linux, Windows, Mac.
 
diff --git a/googletest/docs/faq.md b/googletest/docs/faq.md
index 54584548..d6ae53c9 100644
--- a/googletest/docs/faq.md
+++ b/googletest/docs/faq.md
@@ -1,770 +1,770 @@
 # Googletest FAQ
 
 
-## Why should test case names and test names not contain underscore?
+## Why should test suite names and test names not contain underscore?
 
 Underscore (`_`) is special, as C++ reserves the following to be used by the
 compiler and the standard library:
 
 1.  any identifier that starts with an `_` followed by an upper-case letter, and
 1.  any identifier that contains two consecutive underscores (i.e. `__`)
     *anywhere* in its name.
 
 User code is *prohibited* from using such identifiers.
 
 Now let's look at what this means for `TEST` and `TEST_F`.
 
-Currently `TEST(TestCaseName, TestName)` generates a class named
-`TestCaseName_TestName_Test`. What happens if `TestCaseName` or `TestName`
+Currently `TEST(TestSuiteName, TestName)` generates a class named
+`TestSuiteName_TestName_Test`. What happens if `TestSuiteName` or `TestName`
 contains `_`?
 
-1.  If `TestCaseName` starts with an `_` followed by an upper-case letter (say,
+1.  If `TestSuiteName` starts with an `_` followed by an upper-case letter (say,
     `_Foo`), we end up with `_Foo_TestName_Test`, which is reserved and thus
     invalid.
-1.  If `TestCaseName` ends with an `_` (say, `Foo_`), we get
+1.  If `TestSuiteName` ends with an `_` (say, `Foo_`), we get
     `Foo__TestName_Test`, which is invalid.
 1.  If `TestName` starts with an `_` (say, `_Bar`), we get
-    `TestCaseName__Bar_Test`, which is invalid.
+    `TestSuiteName__Bar_Test`, which is invalid.
 1.  If `TestName` ends with an `_` (say, `Bar_`), we get
-    `TestCaseName_Bar__Test`, which is invalid.
+    `TestSuiteName_Bar__Test`, which is invalid.
 
-So clearly `TestCaseName` and `TestName` cannot start or end with `_` (Actually,
-`TestCaseName` can start with `_` -- as long as the `_` isn't followed by an
+So clearly `TestSuiteName` and `TestName` cannot start or end with `_` (Actually,
+`TestSuiteName` can start with `_` -- as long as the `_` isn't followed by an
 upper-case letter. But that's getting complicated. So for simplicity we just say
 that it cannot start with `_`.).
 
-It may seem fine for `TestCaseName` and `TestName` to contain `_` in the middle.
+It may seem fine for `TestSuiteName` and `TestName` to contain `_` in the middle.
 However, consider this:
 
 ```c++
 TEST(Time, Flies_Like_An_Arrow) { ... }
 TEST(Time_Flies, Like_An_Arrow) { ... }
 ```
 
 Now, the two `TEST`s will both generate the same class
 (`Time_Flies_Like_An_Arrow_Test`). That's not good.
 
-So for simplicity, we just ask the users to avoid `_` in `TestCaseName` and
+So for simplicity, we just ask the users to avoid `_` in `TestSuiteName` and
 `TestName`. The rule is more constraining than necessary, but it's simple and
 easy to remember. It also gives googletest some wiggle room in case its
 implementation needs to change in the future.
 
 If you violate the rule, there may not be immediate consequences, but your test
 may (just may) break with a new compiler (or a new version of the compiler you
 are using) or with a new version of googletest. Therefore it's best to follow
 the rule.
 
 ## Why does googletest support `EXPECT_EQ(NULL, ptr)` and `ASSERT_EQ(NULL, ptr)` but not `EXPECT_NE(NULL, ptr)` and `ASSERT_NE(NULL, ptr)`?
 
 First of all you can use `EXPECT_NE(nullptr, ptr)` and `ASSERT_NE(nullptr,
 ptr)`. This is the preferred syntax in the style guide because nullptr does not
 have the type problems that NULL does. Which is why NULL does not work.
 
 Due to some peculiarity of C++, it requires some non-trivial template meta
 programming tricks to support using `NULL` as an argument of the `EXPECT_XX()`
 and `ASSERT_XX()` macros. Therefore we only do it where it's most needed
 (otherwise we make the implementation of googletest harder to maintain and more
 error-prone than necessary).
 
 The `EXPECT_EQ()` macro takes the *expected* value as its first argument and the
 *actual* value as the second. It's reasonable that someone wants to write
 `EXPECT_EQ(NULL, some_expression)`, and this indeed was requested several times.
 Therefore we implemented it.
 
 The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the assertion
 fails, you already know that `ptr` must be `NULL`, so it doesn't add any
 information to print `ptr` in this case. That means `EXPECT_TRUE(ptr != NULL)`
 works just as well.
 
 If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll have to
 support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`, we don't have a
 convention on the order of the two arguments for `EXPECT_NE`. This means using
 the template meta programming tricks twice in the implementation, making it even
 harder to understand and maintain. We believe the benefit doesn't justify the
 cost.
 
 Finally, with the growth of the gMock matcher library, we are encouraging people
 to use the unified `EXPECT_THAT(value, matcher)` syntax more often in tests. One
 significant advantage of the matcher approach is that matchers can be easily
 combined to form new matchers, while the `EXPECT_NE`, etc, macros cannot be
 easily combined. Therefore we want to invest more in the matchers than in the
 `EXPECT_XX()` macros.
 
 ## I need to test that different implementations of an interface satisfy some common requirements. Should I use typed tests or value-parameterized tests?
 
 For testing various implementations of the same interface, either typed tests or
 value-parameterized tests can get it done. It's really up to you the user to
 decide which is more convenient for you, depending on your particular case. Some
 rough guidelines:
 
 *   Typed tests can be easier to write if instances of the different
     implementations can be created the same way, modulo the type. For example,
     if all these implementations have a public default constructor (such that
     you can write `new TypeParam`), or if their factory functions have the same
     form (e.g. `CreateInstance<TypeParam>()`).
 *   Value-parameterized tests can be easier to write if you need different code
     patterns to create different implementations' instances, e.g. `new Foo` vs
     `new Bar(5)`. To accommodate for the differences, you can write factory
     function wrappers and pass these function pointers to the tests as their
     parameters.
 *   When a typed test fails, the output includes the name of the type, which can
     help you quickly identify which implementation is wrong. Value-parameterized
     tests cannot do this, so there you'll have to look at the iteration number
     to know which implementation the failure is from, which is less direct.
 *   If you make a mistake writing a typed test, the compiler errors can be
     harder to digest, as the code is templatized.
 *   When using typed tests, you need to make sure you are testing against the
     interface type, not the concrete types (in other words, you want to make
     sure `implicit_cast<MyInterface*>(my_concrete_impl)` works, not just that
     `my_concrete_impl` works). It's less likely to make mistakes in this area
     when using value-parameterized tests.
 
 I hope I didn't confuse you more. :-) If you don't mind, I'd suggest you to give
 both approaches a try. Practice is a much better way to grasp the subtle
 differences between the two tools. Once you have some concrete experience, you
 can much more easily decide which one to use the next time.
 
 ## My death tests became very slow - what happened?
 
 In August 2008 we had to switch the default death test style from `fast` to
 `threadsafe`, as the former is no longer safe now that threaded logging is the
 default. This caused many death tests to slow down. Unfortunately this change
 was necessary.
 
 Please read [Fixing Failing Death Tests](advanced.md#death-test-styles) for what you can
 do.
 
 ## I got some run-time errors about invalid proto descriptors when using `ProtocolMessageEquals`. Help!
 
 **Note:** `ProtocolMessageEquals` and `ProtocolMessageEquiv` are *deprecated*
 now. Please use `EqualsProto`, etc instead.
 
 `ProtocolMessageEquals` and `ProtocolMessageEquiv` were redefined recently and
 are now less tolerant on invalid protocol buffer definitions. In particular, if
 you have a `foo.proto` that doesn't fully qualify the type of a protocol message
 it references (e.g. `message<Bar>` where it should be `message<blah.Bar>`), you
 will now get run-time errors like:
 
 ```
 ... descriptor.cc:...] Invalid proto descriptor for file "path/to/foo.proto":
 ... descriptor.cc:...]  blah.MyMessage.my_field: ".Bar" is not defined.
 ```
 
 If you see this, your `.proto` file is broken and needs to be fixed by making
 the types fully qualified. The new definition of `ProtocolMessageEquals` and
 `ProtocolMessageEquiv` just happen to reveal your bug.
 
 ## My death test modifies some state, but the change seems lost after the death test finishes. Why?
 
 Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
 expected crash won't kill the test program (i.e. the parent process). As a
 result, any in-memory side effects they incur are observable in their respective
 sub-processes, but not in the parent process. You can think of them as running
 in a parallel universe, more or less.
 
 In particular, if you use [gMock](../../googlemock) and the death test statement
 invokes some mock methods, the parent process will think the calls have never
 occurred. Therefore, you may want to move your `EXPECT_CALL` statements inside
 the `EXPECT_DEATH` macro.
 
 ## EXPECT_EQ(htonl(blah), blah_blah) generates weird compiler errors in opt mode. Is this a googletest bug?
 
 Actually, the bug is in `htonl()`.
 
 According to `'man htonl'`, `htonl()` is a *function*, which means it's valid to
 use `htonl` as a function pointer. However, in opt mode `htonl()` is defined as
 a *macro*, which breaks this usage.
 
 Worse, the macro definition of `htonl()` uses a `gcc` extension and is *not*
 standard C++. That hacky implementation has some ad hoc limitations. In
 particular, it prevents you from writing `Foo<sizeof(htonl(x))>()`, where `Foo`
 is a template that has an integral argument.
 
 The implementation of `EXPECT_EQ(a, b)` uses `sizeof(... a ...)` inside a
 template argument, and thus doesn't compile in opt mode when `a` contains a call
 to `htonl()`. It is difficult to make `EXPECT_EQ` bypass the `htonl()` bug, as
 the solution must work with different compilers on various platforms.
 
 `htonl()` has some other problems as described in `//util/endian/endian.h`,
 which defines `ghtonl()` to replace it. `ghtonl()` does the same thing `htonl()`
 does, only without its problems. We suggest you to use `ghtonl()` instead of
 `htonl()`, both in your tests and production code.
 
 `//util/endian/endian.h` also defines `ghtons()`, which solves similar problems
 in `htons()`.
 
 Don't forget to add `//util/endian` to the list of dependencies in the `BUILD`
 file wherever `ghtonl()` and `ghtons()` are used. The library consists of a
 single header file and will not bloat your binary.
 
 ## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong?
 
 If your class has a static data member:
 
 ```c++
 // foo.h
 class Foo {
   ...
   static const int kBar = 100;
 };
 ```
 
 You also need to define it *outside* of the class body in `foo.cc`:
 
 ```c++
 const int Foo::kBar;  // No initializer here.
 ```
 
 Otherwise your code is **invalid C++**, and may break in unexpected ways. In
 particular, using it in googletest comparison assertions (`EXPECT_EQ`, etc) will
 generate an "undefined reference" linker error. The fact that "it used to work"
 doesn't mean it's valid. It just means that you were lucky. :-)
 
 ## Can I derive a test fixture from another?
 
 Yes.
 
 Each test fixture has a corresponding and same named test case. This means only
 one test case can use a particular fixture. Sometimes, however, multiple test
 cases may want to use the same or slightly different fixtures. For example, you
 may want to make sure that all of a GUI library's test cases don't leak
 important system resources like fonts and brushes.
 
 In googletest, you share a fixture among test cases by putting the shared logic
 in a base test fixture, then deriving from that base a separate fixture for each
 test case that wants to use this common logic. You then use `TEST_F()` to write
 tests using each derived fixture.
 
 Typically, your code looks like this:
 
 ```c++
 // Defines a base test fixture.
 class BaseTest : public ::testing::Test {
  protected:
   ...
 };
 
 // Derives a fixture FooTest from BaseTest.
 class FooTest : public BaseTest {
  protected:
   void SetUp() override {
     BaseTest::SetUp();  // Sets up the base fixture first.
     ... additional set-up work ...
   }
 
   void TearDown() override {
     ... clean-up work for FooTest ...
     BaseTest::TearDown();  // Remember to tear down the base fixture
                            // after cleaning up FooTest!
   }
 
   ... functions and variables for FooTest ...
 };
 
 // Tests that use the fixture FooTest.
 TEST_F(FooTest, Bar) { ... }
 TEST_F(FooTest, Baz) { ... }
 
 ... additional fixtures derived from BaseTest ...
 ```
 
 If necessary, you can continue to derive test fixtures from a derived fixture.
 googletest has no limit on how deep the hierarchy can be.
 
 For a complete example using derived test fixtures, see [googletest
 sample](https://github.com/google/googletest/blob/master/googletest/samples/sample5_unittest.cc)
 
 ## My compiler complains "void value not ignored as it ought to be." What does this mean?
 
 You're probably using an `ASSERT_*()` in a function that doesn't return `void`.
 `ASSERT_*()` can only be used in `void` functions, due to exceptions being
 disabled by our build system. Please see more details
 [here](advanced.md#assertion-placement).
 
 ## My death test hangs (or seg-faults). How do I fix it?
 
 In googletest, death tests are run in a child process and the way they work is
 delicate. To write death tests you really need to understand how they work.
 Please make sure you have read [this](advanced.md#how-it-works).
 
 In particular, death tests don't like having multiple threads in the parent
 process. So the first thing you can try is to eliminate creating threads outside
 of `EXPECT_DEATH()`. For example, you may want to use [mocks](../../googlemock)
 or fake objects instead of real ones in your tests.
 
 Sometimes this is impossible as some library you must use may be creating
 threads before `main()` is even reached. In this case, you can try to minimize
 the chance of conflicts by either moving as many activities as possible inside
 `EXPECT_DEATH()` (in the extreme case, you want to move everything inside), or
 leaving as few things as possible in it. Also, you can try to set the death test
 style to `"threadsafe"`, which is safer but slower, and see if it helps.
 
 If you go with thread-safe death tests, remember that they rerun the test
 program from the beginning in the child process. Therefore make sure your
 program can run side-by-side with itself and is deterministic.
 
 In the end, this boils down to good concurrent programming. You have to make
 sure that there is no race conditions or dead locks in your program. No silver
 bullet - sorry!
 
 ## Should I use the constructor/destructor of the test fixture or SetUp()/TearDown()?
 
 The first thing to remember is that googletest does **not** reuse the same test
 fixture object across multiple tests. For each `TEST_F`, googletest will create
 a **fresh** test fixture object, immediately call `SetUp()`, run the test body,
 call `TearDown()`, and then delete the test fixture object.
 
 When you need to write per-test set-up and tear-down logic, you have the choice
 between using the test fixture constructor/destructor or `SetUp()/TearDown()`.
 The former is usually preferred, as it has the following benefits:
 
 *   By initializing a member variable in the constructor, we have the option to
     make it `const`, which helps prevent accidental changes to its value and
     makes the tests more obviously correct.
 *   In case we need to subclass the test fixture class, the subclass'
     constructor is guaranteed to call the base class' constructor *first*, and
     the subclass' destructor is guaranteed to call the base class' destructor
     *afterward*. With `SetUp()/TearDown()`, a subclass may make the mistake of
     forgetting to call the base class' `SetUp()/TearDown()` or call them at the
     wrong time.
 
 You may still want to use `SetUp()/TearDown()` in the following rare cases:
 
 *   In the body of a constructor (or destructor), it's not possible to use the
     `ASSERT_xx` macros. Therefore, if the set-up operation could cause a fatal
     test failure that should prevent the test from running, it's necessary to
     use a `CHECK` macro or to use `SetUp()` instead of a constructor.
 *   If the tear-down operation could throw an exception, you must use
     `TearDown()` as opposed to the destructor, as throwing in a destructor leads
     to undefined behavior and usually will kill your program right away. Note
     that many standard libraries (like STL) may throw when exceptions are
     enabled in the compiler. Therefore you should prefer `TearDown()` if you
     want to write portable tests that work with or without exceptions.
 *   The googletest team is considering making the assertion macros throw on
     platforms where exceptions are enabled (e.g. Windows, Mac OS, and Linux
     client-side), which will eliminate the need for the user to propagate
     failures from a subroutine to its caller. Therefore, you shouldn't use
     googletest assertions in a destructor if your code could run on such a
     platform.
 *   In a constructor or destructor, you cannot make a virtual function call on
     this object. (You can call a method declared as virtual, but it will be
     statically bound.) Therefore, if you need to call a method that will be
     overridden in a derived class, you have to use `SetUp()/TearDown()`.
 
 
 ## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it?
 
 If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is
 overloaded or a template, the compiler will have trouble figuring out which
 overloaded version it should use. `ASSERT_PRED_FORMAT*` and
 `EXPECT_PRED_FORMAT*` don't have this problem.
 
 If you see this error, you might want to switch to
 `(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure
 message. If, however, that is not an option, you can resolve the problem by
 explicitly telling the compiler which version to pick.
 
 For example, suppose you have
 
 ```c++
 bool IsPositive(int n) {
   return n > 0;
 }
 
 bool IsPositive(double x) {
   return x > 0;
 }
 ```
 
 you will get a compiler error if you write
 
 ```c++
 EXPECT_PRED1(IsPositive, 5);
 ```
 
 However, this will work:
 
 ```c++
 EXPECT_PRED1(static_cast<bool (*)(int)>(IsPositive), 5);
 ```
 
 (The stuff inside the angled brackets for the `static_cast` operator is the type
 of the function pointer for the `int`-version of `IsPositive()`.)
 
 As another example, when you have a template function
 
 ```c++
 template <typename T>
 bool IsNegative(T x) {
   return x < 0;
 }
 ```
 
 you can use it in a predicate assertion like this:
 
 ```c++
 ASSERT_PRED1(IsNegative<int>, -5);
 ```
 
 Things are more interesting if your template has more than one parameters. The
 following won't compile:
 
 ```c++
 ASSERT_PRED2(GreaterThan<int, int>, 5, 0);
 ```
 
 as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments, which
 is one more than expected. The workaround is to wrap the predicate function in
 parentheses:
 
 ```c++
 ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
 ```
 
 
 ## My compiler complains about "ignoring return value" when I call RUN_ALL_TESTS(). Why?
 
 Some people had been ignoring the return value of `RUN_ALL_TESTS()`. That is,
 instead of
 
 ```c++
   return RUN_ALL_TESTS();
 ```
 
 they write
 
 ```c++
   RUN_ALL_TESTS();
 ```
 
 This is **wrong and dangerous**. The testing services needs to see the return
 value of `RUN_ALL_TESTS()` in order to determine if a test has passed. If your
 `main()` function ignores it, your test will be considered successful even if it
 has a googletest assertion failure. Very bad.
 
 We have decided to fix this (thanks to Michael Chastain for the idea). Now, your
 code will no longer be able to ignore `RUN_ALL_TESTS()` when compiled with
 `gcc`. If you do so, you'll get a compiler error.
 
 If you see the compiler complaining about you ignoring the return value of
 `RUN_ALL_TESTS()`, the fix is simple: just make sure its value is used as the
 return value of `main()`.
 
 But how could we introduce a change that breaks existing tests? Well, in this
 case, the code was already broken in the first place, so we didn't break it. :-)
 
 ## My compiler complains that a constructor (or destructor) cannot return a value. What's going on?
 
 Due to a peculiarity of C++, in order to support the syntax for streaming
 messages to an `ASSERT_*`, e.g.
 
 ```c++
   ASSERT_EQ(1, Foo()) << "blah blah" << foo;
 ```
 
 we had to give up using `ASSERT*` and `FAIL*` (but not `EXPECT*` and
 `ADD_FAILURE*`) in constructors and destructors. The workaround is to move the
 content of your constructor/destructor to a private void member function, or
 switch to `EXPECT_*()` if that works. This
 [section](advanced.md#assertion-placement) in the user's guide explains it.
 
 ## My SetUp() function is not called. Why?
 
 C++ is case-sensitive. Did you spell it as `Setup()`?
 
-Similarly, sometimes people spell `SetUpTestCase()` as `SetupTestCase()` and
+Similarly, sometimes people spell `SetUpTestSuite()` as `SetupTestSuite()` and
 wonder why it's never called.
 
 ## How do I jump to the line of a failure in Emacs directly?
 
 googletest's failure message format is understood by Emacs and many other IDEs,
 like acme and XCode. If a googletest message is in a compilation buffer in
 Emacs, then it's clickable.
 
 
 ## I have several test cases which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious.
 
 You don't have to. Instead of
 
 ```c++
 class FooTest : public BaseTest {};
 
 TEST_F(FooTest, Abc) { ... }
 TEST_F(FooTest, Def) { ... }
 
 class BarTest : public BaseTest {};
 
 TEST_F(BarTest, Abc) { ... }
 TEST_F(BarTest, Def) { ... }
 ```
 
 you can simply `typedef` the test fixtures:
 
 ```c++
 typedef BaseTest FooTest;
 
 TEST_F(FooTest, Abc) { ... }
 TEST_F(FooTest, Def) { ... }
 
 typedef BaseTest BarTest;
 
 TEST_F(BarTest, Abc) { ... }
 TEST_F(BarTest, Def) { ... }
 ```
 
 ## googletest output is buried in a whole bunch of LOG messages. What do I do?
 
 The googletest output is meant to be a concise and human-friendly report. If
 your test generates textual output itself, it will mix with the googletest
 output, making it hard to read. However, there is an easy solution to this
 problem.
 
 Since `LOG` messages go to stderr, we decided to let googletest output go to
 stdout. This way, you can easily separate the two using redirection. For
 example:
 
 ```shell
 $ ./my_test > gtest_output.txt
 ```
 
 
 ## Why should I prefer test fixtures over global variables?
 
 There are several good reasons:
 
 1.  It's likely your test needs to change the states of its global variables.
     This makes it difficult to keep side effects from escaping one test and
     contaminating others, making debugging difficult. By using fixtures, each
     test has a fresh set of variables that's different (but with the same
     names). Thus, tests are kept independent of each other.
 1.  Global variables pollute the global namespace.
 1.  Test fixtures can be reused via subclassing, which cannot be done easily
     with global variables. This is useful if many test cases have something in
     common.
 
 
     ## What can the statement argument in ASSERT_DEATH() be?
 
 `ASSERT_DEATH(*statement*, *regex*)` (or any death assertion macro) can be used
 wherever `*statement*` is valid. So basically `*statement*` can be any C++
 statement that makes sense in the current context. In particular, it can
 reference global and/or local variables, and can be:
 
 *   a simple function call (often the case),
 *   a complex expression, or
 *   a compound statement.
 
 Some examples are shown here:
 
 ```c++
 // A death test can be a simple function call.
 TEST(MyDeathTest, FunctionCall) {
   ASSERT_DEATH(Xyz(5), "Xyz failed");
 }
 
 // Or a complex expression that references variables and functions.
 TEST(MyDeathTest, ComplexExpression) {
   const bool c = Condition();
   ASSERT_DEATH((c ? Func1(0) : object2.Method("test")),
                "(Func1|Method) failed");
 }
 
 // Death assertions can be used any where in a function.  In
 // particular, they can be inside a loop.
 TEST(MyDeathTest, InsideLoop) {
   // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die.
   for (int i = 0; i < 5; i++) {
     EXPECT_DEATH_M(Foo(i), "Foo has \\d+ errors",
                    ::testing::Message() << "where i is " << i);
   }
 }
 
 // A death assertion can contain a compound statement.
 TEST(MyDeathTest, CompoundStatement) {
   // Verifies that at lease one of Bar(0), Bar(1), ..., and
   // Bar(4) dies.
   ASSERT_DEATH({
     for (int i = 0; i < 5; i++) {
       Bar(i);
     }
   },
   "Bar has \\d+ errors");
 }
 ```
 
 gtest-death-test_test.cc contains more examples if you are interested.
 
 ## I have a fixture class `FooTest`, but `TEST_F(FooTest, Bar)` gives me error ``"no matching function for call to `FooTest::FooTest()'"``. Why?
 
 Googletest needs to be able to create objects of your test fixture class, so it
 must have a default constructor. Normally the compiler will define one for you.
 However, there are cases where you have to define your own:
 
 *   If you explicitly declare a non-default constructor for class `FooTest`
     (`DISALLOW_EVIL_CONSTRUCTORS()` does this), then you need to define a
     default constructor, even if it would be empty.
 *   If `FooTest` has a const non-static data member, then you have to define the
     default constructor *and* initialize the const member in the initializer
     list of the constructor. (Early versions of `gcc` doesn't force you to
     initialize the const member. It's a bug that has been fixed in `gcc 4`.)
 
 ## Why does ASSERT_DEATH complain about previous threads that were already joined?
 
 With the Linux pthread library, there is no turning back once you cross the line
 from single thread to multiple threads. The first time you create a thread, a
 manager thread is created in addition, so you get 3, not 2, threads. Later when
 the thread you create joins the main thread, the thread count decrements by 1,
 but the manager thread will never be killed, so you still have 2 threads, which
 means you cannot safely run a death test.
 
 The new NPTL thread library doesn't suffer from this problem, as it doesn't
 create a manager thread. However, if you don't control which machine your test
 runs on, you shouldn't depend on this.
 
 ## Why does googletest require the entire test case, instead of individual tests, to be named *DeathTest when it uses ASSERT_DEATH?
 
 googletest does not interleave tests from different test cases. That is, it runs
 all tests in one test case first, and then runs all tests in the next test case,
 and so on. googletest does this because it needs to set up a test case before
 the first test in it is run, and tear it down afterwords. Splitting up the test
 case would require multiple set-up and tear-down processes, which is inefficient
 and makes the semantics unclean.
 
 If we were to determine the order of tests based on test name instead of test
 case name, then we would have a problem with the following situation:
 
 ```c++
 TEST_F(FooTest, AbcDeathTest) { ... }
 TEST_F(FooTest, Uvw) { ... }
 
 TEST_F(BarTest, DefDeathTest) { ... }
 TEST_F(BarTest, Xyz) { ... }
 ```
 
 Since `FooTest.AbcDeathTest` needs to run before `BarTest.Xyz`, and we don't
 interleave tests from different test cases, we need to run all tests in the
 `FooTest` case before running any test in the `BarTest` case. This contradicts
 with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
 
 ## But I don't like calling my entire test case \*DeathTest when it contains both death tests and non-death tests. What do I do?
 
 You don't have to, but if you like, you may split up the test case into
 `FooTest` and `FooDeathTest`, where the names make it clear that they are
 related:
 
 ```c++
 class FooTest : public ::testing::Test { ... };
 
 TEST_F(FooTest, Abc) { ... }
 TEST_F(FooTest, Def) { ... }
 
 using FooDeathTest = FooTest;
 
 TEST_F(FooDeathTest, Uvw) { ... EXPECT_DEATH(...) ... }
 TEST_F(FooDeathTest, Xyz) { ... ASSERT_DEATH(...) ... }
 ```
 
 ## googletest prints the LOG messages in a death test's child process only when the test fails. How can I see the LOG messages when the death test succeeds?
 
 Printing the LOG messages generated by the statement inside `EXPECT_DEATH()`
 makes it harder to search for real problems in the parent's log. Therefore,
 googletest only prints them when the death test has failed.
 
 If you really need to see such LOG messages, a workaround is to temporarily
 break the death test (e.g. by changing the regex pattern it is expected to
 match). Admittedly, this is a hack. We'll consider a more permanent solution
 after the fork-and-exec-style death tests are implemented.
 
 ## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives?
 
 If you use a user-defined type `FooType` in an assertion, you must make sure
 there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function
 defined such that we can print a value of `FooType`.
 
 In addition, if `FooType` is declared in a name space, the `<<` operator also
 needs to be defined in the *same* name space. See go/totw/49 for details.
 
 ## How do I suppress the memory leak messages on Windows?
 
 Since the statically initialized googletest singleton requires allocations on
 the heap, the Visual C++ memory leak detector will report memory leaks at the
 end of the program run. The easiest way to avoid this is to use the
 `_CrtMemCheckpoint` and `_CrtMemDumpAllObjectsSince` calls to not report any
 statically initialized heap objects. See MSDN for more details and additional
 heap check/debug routines.
 
 
 ## How can my code detect if it is running in a test?
 
 If you write code that sniffs whether it's running in a test and does different
 things accordingly, you are leaking test-only logic into production code and
 there is no easy way to ensure that the test-only code paths aren't run by
 mistake in production. Such cleverness also leads to
 [Heisenbugs](https://en.wikipedia.org/wiki/Heisenbug). Therefore we strongly
 advise against the practice, and googletest doesn't provide a way to do it.
 
 In general, the recommended way to cause the code to behave differently under
 test is [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection). You can inject
 different functionality from the test and from the production code. Since your
 production code doesn't link in the for-test logic at all (the
 [`testonly`](https://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly)
 attribute for BUILD targets helps to ensure that), there is no danger in
 accidentally running it.
 
 However, if you *really*, *really*, *really* have no choice, and if you follow
 the rule of ending your test program names with `_test`, you can use the
 *horrible* hack of sniffing your executable name (`argv[0]` in `main()`) to know
 whether the code is under test.
 
 
 ## How do I temporarily disable a test?
 
 If you have a broken test that you cannot fix right away, you can add the
 DISABLED_ prefix to its name. This will exclude it from execution. This is
 better than commenting out the code or using #if 0, as disabled tests are still
 compiled (and thus won't rot).
 
 To include disabled tests in test execution, just invoke the test program with
 the --gtest_also_run_disabled_tests flag.
 
 ## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces?
 
 Yes.
 
 The rule is **all test methods in the same test case must use the same fixture
 class.** This means that the following is **allowed** because both tests use the
 same fixture class (`::testing::Test`).
 
 ```c++
 namespace foo {
 TEST(CoolTest, DoSomething) {
   SUCCEED();
 }
 }  // namespace foo
 
 namespace bar {
 TEST(CoolTest, DoSomething) {
   SUCCEED();
 }
 }  // namespace bar
 ```
 
 However, the following code is **not allowed** and will produce a runtime error
 from googletest because the test methods are using different test fixture
 classes with the same test case name.
 
 ```c++
 namespace foo {
 class CoolTest : public ::testing::Test {};  // Fixture foo::CoolTest
 TEST_F(CoolTest, DoSomething) {
   SUCCEED();
 }
 }  // namespace foo
 
 namespace bar {
 class CoolTest : public ::testing::Test {};  // Fixture: bar::CoolTest
 TEST_F(CoolTest, DoSomething) {
   SUCCEED();
 }
 }  // namespace bar
 ```
diff --git a/googletest/docs/primer.md b/googletest/docs/primer.md
index 902e8274..6344ba33 100644
--- a/googletest/docs/primer.md
+++ b/googletest/docs/primer.md
@@ -1,566 +1,564 @@
 # Googletest Primer
 
 
 ## Introduction: Why googletest?
 
 *googletest* helps you write better C++ tests.
 
 googletest is a testing framework developed by the Testing
 Technology team with Google's specific
 requirements and constraints in mind. No matter whether you work on Linux,
 Windows, or a Mac, if you write C++ code, googletest can help you. And it
 supports *any* kind of tests, not just unit tests.
 
 So what makes a good test, and how does googletest fit in? We believe:
 
 1.  Tests should be *independent* and *repeatable*. It's a pain to debug a test
     that succeeds or fails as a result of other tests. googletest isolates the
     tests by running each of them on a different object. When a test fails,
     googletest allows you to run it in isolation for quick debugging.
 1.  Tests should be well *organized* and reflect the structure of the tested
     code. googletest groups related tests into test cases that can share data
     and subroutines. This common pattern is easy to recognize and makes tests
     easy to maintain. Such consistency is especially helpful when people switch
     projects and start to work on a new code base.
 1.  Tests should be *portable* and *reusable*. Google has a lot of code that is
     platform-neutral, its tests should also be platform-neutral. googletest
     works on different OSes, with different compilers (gcc, icc, and MSVC), with
     or without exceptions, so googletest tests can easily work with a variety of
     configurations.
 1.  When tests fail, they should provide as much *information* about the problem
     as possible. googletest doesn't stop at the first test failure. Instead, it
     only stops the current test and continues with the next. You can also set up
     tests that report non-fatal failures after which the current test continues.
     Thus, you can detect and fix multiple bugs in a single run-edit-compile
     cycle.
 1.  The testing framework should liberate test writers from housekeeping chores
     and let them focus on the test *content*. googletest automatically keeps
     track of all tests defined, and doesn't require the user to enumerate them
     in order to run them.
 1.  Tests should be *fast*. With googletest, you can reuse shared resources
     across tests and pay for the set-up/tear-down only once, without making
     tests depend on each other.
 
 Since googletest is based on the popular xUnit architecture, you'll feel right
 at home if you've used JUnit or PyUnit before. If not, it will take you about 10
 minutes to learn the basics and get started. So let's go!
 
 ## Beware of the nomenclature
 
 _Note:_ There might be some confusion of idea due to different
 definitions of the terms _Test_, _Test Case_ and _Test Suite_, so beware
 of misunderstanding these.
 
 Historically, googletest started to use the term _Test Case_ for grouping
 related tests, whereas current publications including the International Software
 Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) and various
 textbooks on Software Quality use the term _[Test
 Suite](http://glossary.istqb.org/search/test%20suite)_ for this.
 
 The related term _Test_, as it is used in the googletest, is corresponding to
 the term _[Test Case](http://glossary.istqb.org/search/test%20case)_ of ISTQB
 and others.
 
-The term _Test_ is commonly of broad enough sense, including ISTQB's
-definition of _Test Case_, so it's not much of a problem here. But the
-term _Test Case_ as used in Google Test is of contradictory sense and thus confusing.
+The term _Test_ is commonly of broad enough sense, including ISTQB's definition
+of _Test Case_, so it's not much of a problem here. But the term _Test Case_ as
+was used in Google Test is of contradictory sense and thus confusing.
 
-Unfortunately replacing the term _Test Case_ by _Test Suite_ throughout the
-googletest is not easy without breaking dependent projects, as `TestCase` is
-part of the public API at various places.
+googletest recently started replacing the term _Test Case_ by _Test Suite_ The
+preferred API is TestSuite*. The older TestCase* API is being slowly deprecated
+and refactored away
 
-So for the time being, please be aware of the different definitions of
-the terms:
+So please be aware of the different definitions of the terms:
 
 Meaning                                                                              | googletest Term                                                                                            | [ISTQB](http://www.istqb.org/) Term
 :----------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- | :----------------------------------
 Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests)                                                                                    | [Test Case](http://glossary.istqb.org/search/test%20case)
-A set of several tests related to one component                                      | [TestCase](#basic-concepts) | [TestSuite](http://glossary.istqb.org/search/test%20suite)
 
 ## Basic Concepts
 
 When using googletest, you start by writing *assertions*, which are statements
 that check whether a condition is true. An assertion's result can be *success*,
 *nonfatal failure*, or *fatal failure*. If a fatal failure occurs, it aborts the
 current function; otherwise the program continues normally.
 
 *Tests* use assertions to verify the tested code's behavior. If a test crashes
 or has a failed assertion, then it *fails*; otherwise it *succeeds*.
 
 A *test case* contains one or many tests. You should group your tests into test
 cases that reflect the structure of the tested code. When multiple tests in a
 test case need to share common objects and subroutines, you can put them into a
 *test fixture* class.
 
 A *test program* can contain multiple test cases.
 
 We'll now explain how to write a test program, starting at the individual
 assertion level and building up to tests and test cases.
 
 ## Assertions
 
 googletest assertions are macros that resemble function calls. You test a class
 or function by making assertions about its behavior. When an assertion fails,
 googletest prints the assertion's source file and line number location, along
 with a failure message. You may also supply a custom failure message which will
 be appended to googletest's message.
 
 The assertions come in pairs that test the same thing but have different effects
 on the current function. `ASSERT_*` versions generate fatal failures when they
 fail, and **abort the current function**. `EXPECT_*` versions generate nonfatal
 failures, which don't abort the current function. Usually `EXPECT_*` are
 preferred, as they allow more than one failure to be reported in a test.
 However, you should use `ASSERT_*` if it doesn't make sense to continue when the
 assertion in question fails.
 
 Since a failed `ASSERT_*` returns from the current function immediately,
 possibly skipping clean-up code that comes after it, it may cause a space leak.
 Depending on the nature of the leak, it may or may not be worth fixing - so keep
 this in mind if you get a heap checker error in addition to assertion errors.
 
 To provide a custom failure message, simply stream it into the macro using the
 `<<` operator, or a sequence of such operators. An example:
 
 ```c++
 ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
 
 for (int i = 0; i < x.size(); ++i) {
   EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
 }
 ```
 
 Anything that can be streamed to an `ostream` can be streamed to an assertion
 macro--in particular, C strings and `string` objects. If a wide string
 (`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is
 streamed to an assertion, it will be translated to UTF-8 when printed.
 
 ### Basic Assertions
 
 These assertions do basic true/false condition testing.
 
 Fatal assertion            | Nonfatal assertion         | Verifies
 -------------------------- | -------------------------- | --------------------
 `ASSERT_TRUE(condition);`  | `EXPECT_TRUE(condition);`  | `condition` is true
 `ASSERT_FALSE(condition);` | `EXPECT_FALSE(condition);` | `condition` is false
 
 Remember, when they fail, `ASSERT_*` yields a fatal failure and returns from the
 current function, while `EXPECT_*` yields a nonfatal failure, allowing the
 function to continue running. In either case, an assertion failure means its
 containing test fails.
 
 **Availability**: Linux, Windows, Mac.
 
 ### Binary Comparison
 
 This section describes assertions that compare two values.
 
 Fatal assertion          | Nonfatal assertion       | Verifies
 ------------------------ | ------------------------ | --------------
 `ASSERT_EQ(val1, val2);` | `EXPECT_EQ(val1, val2);` | `val1 == val2`
 `ASSERT_NE(val1, val2);` | `EXPECT_NE(val1, val2);` | `val1 != val2`
 `ASSERT_LT(val1, val2);` | `EXPECT_LT(val1, val2);` | `val1 < val2`
 `ASSERT_LE(val1, val2);` | `EXPECT_LE(val1, val2);` | `val1 <= val2`
 `ASSERT_GT(val1, val2);` | `EXPECT_GT(val1, val2);` | `val1 > val2`
 `ASSERT_GE(val1, val2);` | `EXPECT_GE(val1, val2);` | `val1 >= val2`
 
 Value arguments must be comparable by the assertion's comparison operator or
 you'll get a compiler error. We used to require the arguments to support the
 `<<` operator for streaming to an `ostream`, but it's no longer necessary. If
 `<<` is supported, it will be called to print the arguments when the assertion
 fails; otherwise googletest will attempt to print them in the best way it can.
 For more details and how to customize the printing of the arguments, see
 gMock [recipe](../../googlemock/docs/CookBook.md#teaching-google-mock-how-to-print-your-values).).
 
 These assertions can work with a user-defined type, but only if you define the
 corresponding comparison operator (e.g. `==`, `<`, etc). Since this is
 discouraged by the Google [C++ Style
 Guide](https://google.github.io/styleguide/cppguide.html#Operator_Overloading),
 you may need to use `ASSERT_TRUE()` or `EXPECT_TRUE()` to assert the equality of
 two objects of a user-defined type.
 
 However, when possible, `ASSERT_EQ(actual, expected)` is preferred to
 `ASSERT_TRUE(actual == expected)`, since it tells you `actual` and `expected`'s
 values on failure.
 
 Arguments are always evaluated exactly once. Therefore, it's OK for the
 arguments to have side effects. However, as with any ordinary C/C++ function,
 the arguments' evaluation order is undefined (i.e. the compiler is free to
 choose any order) and your code should not depend on any particular argument
 evaluation order.
 
 `ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it
 tests if they are in the same memory location, not if they have the same value.
 Therefore, if you want to compare C strings (e.g. `const char*`) by value, use
 `ASSERT_STREQ()`, which will be described later on. In particular, to assert
 that a C string is `NULL`, use `ASSERT_STREQ(c_string, NULL)`. Consider use
 `ASSERT_EQ(c_string, nullptr)` if c++11 is supported. To compare two `string`
 objects, you should use `ASSERT_EQ`.
 
 When doing pointer comparisons use `*_EQ(ptr, nullptr)` and `*_NE(ptr, nullptr)`
 instead of `*_EQ(ptr, NULL)` and `*_NE(ptr, NULL)`. This is because `nullptr` is
 typed while `NULL` is not. See [FAQ](faq.md#why-does-googletest-support-expect_eqnull-ptr-and-assert_eqnull-ptr-but-not-expect_nenull-ptr-and-assert_nenull-ptr)
 for more details.
 
 If you're working with floating point numbers, you may want to use the floating
 point variations of some of these macros in order to avoid problems caused by
 rounding. See [Advanced googletest Topics](advanced.md) for details.
 
 Macros in this section work with both narrow and wide string objects (`string`
 and `wstring`).
 
 **Availability**: Linux, Windows, Mac.
 
 **Historical note**: Before February 2016 `*_EQ` had a convention of calling it
 as `ASSERT_EQ(expected, actual)`, so lots of existing code uses this order. Now
 `*_EQ` treats both parameters in the same way.
 
 ### String Comparison
 
 The assertions in this group compare two **C strings**. If you want to compare
 two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead.
 
 | Fatal assertion                 | Nonfatal assertion              | Verifies                                                 |
 | ------------------------------- | ------------------------------- | -------------------------------------------------------- |
 | `ASSERT_STREQ(str1, str2);`     | `EXPECT_STREQ(str1, str2);`     | the two C strings have the same content                  |
 | `ASSERT_STRNE(str1, str2);`     | `EXPECT_STRNE(str1, str2);`     | the two C strings have different contents                |
 | `ASSERT_STRCASEEQ(str1, str2);` | `EXPECT_STRCASEEQ(str1, str2);` | the two C strings have the same content, ignoring case   |
 | `ASSERT_STRCASENE(str1, str2);` | `EXPECT_STRCASENE(str1, str2);` | the two C strings have different contents, ignoring case |
 
 Note that "CASE" in an assertion name means that case is ignored. A `NULL`
 pointer and an empty string are considered *different*.
 
 `*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a comparison
 of two wide strings fails, their values will be printed as UTF-8 narrow strings.
 
 **Availability**: Linux, Windows, Mac.
 
 **See also**: For more string comparison tricks (substring, prefix, suffix, and
 regular expression matching, for example), see
 [this](https://github.com/google/googletest/blob/master/googletest/docs/advanced.md)
 in the Advanced googletest Guide.
 
 ## Simple Tests
 
 To create a test:
 
 1.  Use the `TEST()` macro to define and name a test function, These are
     ordinary C++ functions that don't return a value.
 1.  In this function, along with any valid C++ statements you want to include,
     use the various googletest assertions to check values.
 1.  The test's result is determined by the assertions; if any assertion in the
     test fails (either fatally or non-fatally), or if the test crashes, the
     entire test fails. Otherwise, it succeeds.
 
 ```c++
-TEST(TestCaseName, TestName) {
+TEST(TestSuiteName, TestName) {
   ... test body ...
 }
 ```
 
 `TEST()` arguments go from general to specific. The *first* argument is the name
 of the test case, and the *second* argument is the test's name within the test
 case. Both names must be valid C++ identifiers, and they should not contain
 underscore (`_`). A test's *full name* consists of its containing test case and
 its individual name. Tests from different test cases can have the same
 individual name.
 
 For example, let's take a simple integer function:
 
 ```c++
 int Factorial(int n);  // Returns the factorial of n
 ```
 
 A test case for this function might look like:
 
 ```c++
 // Tests factorial of 0.
 TEST(FactorialTest, HandlesZeroInput) {
   EXPECT_EQ(Factorial(0), 1);
 }
 
 // Tests factorial of positive numbers.
 TEST(FactorialTest, HandlesPositiveInput) {
   EXPECT_EQ(Factorial(1), 1);
   EXPECT_EQ(Factorial(2), 2);
   EXPECT_EQ(Factorial(3), 6);
   EXPECT_EQ(Factorial(8), 40320);
 }
 ```
 
 googletest groups the test results by test cases, so logically-related tests
 should be in the same test case; in other words, the first argument to their
 `TEST()` should be the same. In the above example, we have two tests,
 `HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test case
 `FactorialTest`.
 
 When naming your test cases and tests, you should follow the same convention as
 for [naming functions and
 classes](https://google.github.io/styleguide/cppguide.html#Function_Names).
 
 **Availability**: Linux, Windows, Mac.
 
 ## Test Fixtures: Using the Same Data Configuration for Multiple Tests
 
 If you find yourself writing two or more tests that operate on similar data, you
 can use a *test fixture*. It allows you to reuse the same configuration of
 objects for several different tests.
 
 To create a fixture:
 
 1.  Derive a class from `::testing::Test` . Start its body with `protected:` as
     we'll want to access fixture members from sub-classes.
 1.  Inside the class, declare any objects you plan to use.
 1.  If necessary, write a default constructor or `SetUp()` function to prepare
     the objects for each test. A common mistake is to spell `SetUp()` as
     **`Setup()`** with a small `u` - Use `override` in C++11 to make sure you
     spelled it correctly
 1.  If necessary, write a destructor or `TearDown()` function to release any
     resources you allocated in `SetUp()` . To learn when you should use the
     constructor/destructor and when you should use `SetUp()/TearDown()`, read
     this [FAQ](faq.md#should-i-use-the-constructordestructor-of-the-test-fixture-or-setupteardown) entry.
 1.  If needed, define subroutines for your tests to share.
 
 When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
 access objects and subroutines in the test fixture:
 
 ```c++
-TEST_F(TestCaseName, TestName) {
+TEST_F(TestSuiteName, TestName) {
   ... test body ...
 }
 ```
 
 Like `TEST()`, the first argument is the test case name, but for `TEST_F()` this
 must be the name of the test fixture class. You've probably guessed: `_F` is for
 fixture.
 
 Unfortunately, the C++ macro system does not allow us to create a single macro
 that can handle both types of tests. Using the wrong macro causes a compiler
 error.
 
 Also, you must first define a test fixture class before using it in a
 `TEST_F()`, or you'll get the compiler error "`virtual outside class
 declaration`".
 
 For each test defined with `TEST_F()` , googletest will create a *fresh* test
 fixture at runtime, immediately initialize it via `SetUp()` , run the test,
 clean up by calling `TearDown()` , and then delete the test fixture. Note that
 different tests in the same test case have different test fixture objects, and
 googletest always deletes a test fixture before it creates the next one.
 googletest does **not** reuse the same test fixture for multiple tests. Any
 changes one test makes to the fixture do not affect other tests.
 
 As an example, let's write tests for a FIFO queue class named `Queue`, which has
 the following interface:
 
 ```c++
 template <typename E>  // E is the element type.
 class Queue {
  public:
   Queue();
   void Enqueue(const E& element);
   E* Dequeue();  // Returns NULL if the queue is empty.
   size_t size() const;
   ...
 };
 ```
 
 First, define a fixture class. By convention, you should give it the name
 `FooTest` where `Foo` is the class being tested.
 
 ```c++
 class QueueTest : public ::testing::Test {
  protected:
   void SetUp() override {
      q1_.Enqueue(1);
      q2_.Enqueue(2);
      q2_.Enqueue(3);
   }
 
   // void TearDown() override {}
 
   Queue<int> q0_;
   Queue<int> q1_;
   Queue<int> q2_;
 };
 ```
 
 In this case, `TearDown()` is not needed since we don't have to clean up after
 each test, other than what's already done by the destructor.
 
 Now we'll write tests using `TEST_F()` and this fixture.
 
 ```c++
 TEST_F(QueueTest, IsEmptyInitially) {
   EXPECT_EQ(q0_.size(), 0);
 }
 
 TEST_F(QueueTest, DequeueWorks) {
   int* n = q0_.Dequeue();
   EXPECT_EQ(n, nullptr);
 
   n = q1_.Dequeue();
   ASSERT_NE(n, nullptr);
   EXPECT_EQ(*n, 1);
   EXPECT_EQ(q1_.size(), 0);
   delete n;
 
   n = q2_.Dequeue();
   ASSERT_NE(n, nullptr);
   EXPECT_EQ(*n, 2);
   EXPECT_EQ(q2_.size(), 1);
   delete n;
 }
 ```
 
 The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is
 to use `EXPECT_*` when you want the test to continue to reveal more errors after
 the assertion failure, and use `ASSERT_*` when continuing after failure doesn't
 make sense. For example, the second assertion in the `Dequeue` test is
 =ASSERT_NE(nullptr, n)=, as we need to dereference the pointer `n` later, which
 would lead to a segfault when `n` is `NULL`.
 
 When these tests run, the following happens:
 
 1.  googletest constructs a `QueueTest` object (let's call it `t1` ).
 1.  `t1.SetUp()` initializes `t1` .
 1.  The first test ( `IsEmptyInitially` ) runs on `t1` .
 1.  `t1.TearDown()` cleans up after the test finishes.
 1.  `t1` is destructed.
 1.  The above steps are repeated on another `QueueTest` object, this time
     running the `DequeueWorks` test.
 
 **Availability**: Linux, Windows, Mac.
 
 
 ## Invoking the Tests
 
 `TEST()` and `TEST_F()` implicitly register their tests with googletest. So,
 unlike with many other C++ testing frameworks, you don't have to re-list all
 your defined tests in order to run them.
 
 After defining your tests, you can run them with `RUN_ALL_TESTS()` , which
 returns `0` if all the tests are successful, or `1` otherwise. Note that
 `RUN_ALL_TESTS()` runs *all tests* in your link unit -- they can be from
 different test cases, or even different source files.
 
 When invoked, the `RUN_ALL_TESTS()` macro:
 
 1. Saves the state of all googletest flags
 
 *   Creates a test fixture object for the first test.
 
 *   Initializes it via `SetUp()`.
 
 *   Runs the test on the fixture object.
 
 *   Cleans up the fixture via `TearDown()`.
 
 *   Deletes the fixture.
 
 * Restores the state of all googletest flags
 
 *   Repeats the above steps for the next test, until all tests have run.
 
 If a fatal failure happens the subsequent steps will be skipped.
 
 > IMPORTANT: You must **not** ignore the return value of `RUN_ALL_TESTS()`, or
 > you will get a compiler error. The rationale for this design is that the
 > automated testing service determines whether a test has passed based on its
 > exit code, not on its stdout/stderr output; thus your `main()` function must
 > return the value of `RUN_ALL_TESTS()`.
 >
 > Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than
 > once conflicts with some advanced googletest features (e.g. thread-safe [death
 > tests](advanced.md#death-tests)) and thus is not supported.
 
 **Availability**: Linux, Windows, Mac.
 
 ## Writing the main() Function
 
 Write your own main() function, which should
 return the value of `RUN_ALL_TESTS()`
 
 ```c++
 #include "this/package/foo.h"
 #include "gtest/gtest.h"
 
 namespace {
 
 // The fixture for testing class Foo.
 class FooTest : public ::testing::Test {
  protected:
   // You can remove any or all of the following functions if its body
   // is empty.
 
   FooTest() {
      // You can do set-up work for each test here.
   }
 
   ~FooTest() override {
      // You can do clean-up work that doesn't throw exceptions here.
   }
 
   // If the constructor and destructor are not enough for setting up
   // and cleaning up each test, you can define the following methods:
 
   void SetUp() override {
      // Code here will be called immediately after the constructor (right
      // before each test).
   }
 
   void TearDown() override {
      // Code here will be called immediately after each test (right
      // before the destructor).
   }
 
   // Objects declared here can be used by all tests in the test case for Foo.
 };
 
 // Tests that the Foo::Bar() method does Abc.
 TEST_F(FooTest, MethodBarDoesAbc) {
   const std::string input_filepath = "this/package/testdata/myinputfile.dat";
   const std::string output_filepath = "this/package/testdata/myoutputfile.dat";
   Foo f;
   EXPECT_EQ(f.Bar(input_filepath, output_filepath), 0);
 }
 
 // Tests that Foo does Xyz.
 TEST_F(FooTest, DoesXyz) {
   // Exercises the Xyz feature of Foo.
 }
 
 }  // namespace
 
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
 ```
 
 
 The `::testing::InitGoogleTest()` function parses the command line for
 googletest flags, and removes all recognized flags. This allows the user to
 control a test program's behavior via various flags, which we'll cover in
 [AdvancedGuide](advanced.md). You **must** call this function before calling
 `RUN_ALL_TESTS()`, or the flags won't be properly initialized.
 
 On Windows, `InitGoogleTest()` also works with wide strings, so it can be used
 in programs compiled in `UNICODE` mode as well.
 
 But maybe you think that writing all those main() functions is too much work? We
 agree with you completely and that's why Google Test provides a basic
 implementation of main(). If it fits your needs, then just link your test with
 gtest\_main library and you are good to go.
 
 NOTE: `ParseGUnitFlags()` is deprecated in favor of `InitGoogleTest()`.
 
 
 ## Known Limitations
 
 *   Google Test is designed to be thread-safe. The implementation is thread-safe
     on systems where the `pthreads` library is available. It is currently
     _unsafe_ to use Google Test assertions from two threads concurrently on
     other systems (e.g. Windows). In most tests this is not an issue as usually
     the assertions are done in the main thread. If you want to help, you can
     volunteer to implement the necessary synchronization primitives in
     `gtest-port.h` for your platform.
diff --git a/googletest/include/gtest/gtest.h b/googletest/include/gtest/gtest.h
index 3c725751..bb547bc0 100644
--- a/googletest/include/gtest/gtest.h
+++ b/googletest/include/gtest/gtest.h
@@ -1,2504 +1,2504 @@
 // Copyright 2005, 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.
 
 //
 // The Google C++ Testing and Mocking Framework (Google Test)
 //
 // This header file defines the public API for Google Test.  It should be
 // included by any test program that uses Google Test.
 //
 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
 // leave some internal implementation details in this header file.
 // They are clearly marked by comments like this:
 //
 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 //
 // Such code is NOT meant to be used by a user directly, and is subject
 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
 // program!
 //
 // Acknowledgment: Google Test borrowed the idea of automatic test
 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
 // easyUnit framework.
 
 // GOOGLETEST_CM0001 DO NOT DELETE
 
 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
 #define GTEST_INCLUDE_GTEST_GTEST_H_
 
 #include <limits>
 #include <memory>
 #include <ostream>
 #include <vector>
 
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"
 #include "gtest/gtest-death-test.h"
 #include "gtest/gtest-matchers.h"
 #include "gtest/gtest-message.h"
 #include "gtest/gtest-param-test.h"
 #include "gtest/gtest-printers.h"
 #include "gtest/gtest_prod.h"
 #include "gtest/gtest-test-part.h"
 #include "gtest/gtest-typed-test.h"
 
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
 
 // Depending on the platform, different string classes are available.
 // On Linux, in addition to ::std::string, Google also makes use of
 // class ::string, which has the same interface as ::std::string, but
 // has a different implementation.
 //
 // You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
 // ::string is available AND is a distinct type to ::std::string, or
 // define it to 0 to indicate otherwise.
 //
 // If ::std::string and ::string are the same class on your platform
 // due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
 //
 // If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
 // heuristically.
 
 namespace testing {
 
 // Silence C4100 (unreferenced formal parameter) and 4805
 // unsafe mix of type 'const int' and type 'const bool'
 #ifdef _MSC_VER
 # pragma warning(push)
 # pragma warning(disable:4805)
 # pragma warning(disable:4100)
 #endif
 
 
 // Declares the flags.
 
 // This flag temporary enables the disabled tests.
 GTEST_DECLARE_bool_(also_run_disabled_tests);
 
 // This flag brings the debugger on an assertion failure.
 GTEST_DECLARE_bool_(break_on_failure);
 
 // This flag controls whether Google Test catches all test-thrown exceptions
 // and logs them as failures.
 GTEST_DECLARE_bool_(catch_exceptions);
 
 // This flag enables using colors in terminal output. Available values are
 // "yes" to enable colors, "no" (disable colors), or "auto" (the default)
 // to let Google Test decide.
 GTEST_DECLARE_string_(color);
 
 // This flag sets up the filter to select by name using a glob pattern
 // the tests to run. If the filter is not given all tests are executed.
 GTEST_DECLARE_string_(filter);
 
 // This flag controls whether Google Test installs a signal handler that dumps
 // debugging information when fatal signals are raised.
 GTEST_DECLARE_bool_(install_failure_signal_handler);
 
 // This flag causes the Google Test to list tests. None of the tests listed
 // are actually run if the flag is provided.
 GTEST_DECLARE_bool_(list_tests);
 
 // This flag controls whether Google Test emits a detailed XML report to a file
 // in addition to its normal textual output.
 GTEST_DECLARE_string_(output);
 
 // This flags control whether Google Test prints the elapsed time for each
 // test.
 GTEST_DECLARE_bool_(print_time);
 
 // This flags control whether Google Test prints UTF8 characters as text.
 GTEST_DECLARE_bool_(print_utf8);
 
 // This flag specifies the random number seed.
 GTEST_DECLARE_int32_(random_seed);
 
 // This flag sets how many times the tests are repeated. The default value
 // is 1. If the value is -1 the tests are repeating forever.
 GTEST_DECLARE_int32_(repeat);
 
 // This flag controls whether Google Test includes Google Test internal
 // stack frames in failure stack traces.
 GTEST_DECLARE_bool_(show_internal_stack_frames);
 
 // When this flag is specified, tests' order is randomized on every iteration.
 GTEST_DECLARE_bool_(shuffle);
 
 // This flag specifies the maximum number of stack frames to be
 // printed in a failure message.
 GTEST_DECLARE_int32_(stack_trace_depth);
 
 // When this flag is specified, a failed assertion will throw an
 // exception if exceptions are enabled, or exit the program with a
 // non-zero code otherwise. For use with an external test framework.
 GTEST_DECLARE_bool_(throw_on_failure);
 
 // When this flag is set with a "host:port" string, on supported
 // platforms test results are streamed to the specified port on
 // the specified host machine.
 GTEST_DECLARE_string_(stream_result_to);
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
 GTEST_DECLARE_string_(flagfile);
 #endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
 
 // The upper limit for valid stack trace depths.
 const int kMaxStackTraceDepth = 100;
 
 namespace internal {
 
 class AssertHelper;
 class DefaultGlobalTestPartResultReporter;
 class ExecDeathTest;
 class NoExecDeathTest;
 class FinalSuccessChecker;
 class GTestFlagSaver;
 class StreamingListenerTest;
 class TestResultAccessor;
 class TestEventListenersAccessor;
 class TestEventRepeater;
 class UnitTestRecordPropertyTestHelper;
 class WindowsDeathTest;
 class FuchsiaDeathTest;
 class UnitTestImpl* GetUnitTestImpl();
 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                     const std::string& message);
 
 }  // namespace internal
 
 // The friend relationship of some of these classes is cyclic.
 // If we don't forward declare them the compiler might confuse the classes
 // in friendship clauses with same named classes on the scope.
 class Test;
 class TestSuite;
 
 // Old API is still available but deprecated
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 using TestCase = TestSuite;
 #endif
 class TestInfo;
 class UnitTest;
 
 // A class for indicating whether an assertion was successful.  When
 // the assertion wasn't successful, the AssertionResult object
 // remembers a non-empty message that describes how it failed.
 //
 // To create an instance of this class, use one of the factory functions
 // (AssertionSuccess() and AssertionFailure()).
 //
 // This class is useful for two purposes:
 //   1. Defining predicate functions to be used with Boolean test assertions
 //      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
 //   2. Defining predicate-format functions to be
 //      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
 //
 // For example, if you define IsEven predicate:
 //
 //   testing::AssertionResult IsEven(int n) {
 //     if ((n % 2) == 0)
 //       return testing::AssertionSuccess();
 //     else
 //       return testing::AssertionFailure() << n << " is odd";
 //   }
 //
 // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
 // will print the message
 //
 //   Value of: IsEven(Fib(5))
 //     Actual: false (5 is odd)
 //   Expected: true
 //
 // instead of a more opaque
 //
 //   Value of: IsEven(Fib(5))
 //     Actual: false
 //   Expected: true
 //
 // in case IsEven is a simple Boolean predicate.
 //
 // If you expect your predicate to be reused and want to support informative
 // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
 // about half as often as positive ones in our tests), supply messages for
 // both success and failure cases:
 //
 //   testing::AssertionResult IsEven(int n) {
 //     if ((n % 2) == 0)
 //       return testing::AssertionSuccess() << n << " is even";
 //     else
 //       return testing::AssertionFailure() << n << " is odd";
 //   }
 //
 // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
 //
 //   Value of: IsEven(Fib(6))
 //     Actual: true (8 is even)
 //   Expected: false
 //
 // NB: Predicates that support negative Boolean assertions have reduced
 // performance in positive ones so be careful not to use them in tests
 // that have lots (tens of thousands) of positive Boolean assertions.
 //
 // To use this class with EXPECT_PRED_FORMAT assertions such as:
 //
 //   // Verifies that Foo() returns an even number.
 //   EXPECT_PRED_FORMAT1(IsEven, Foo());
 //
 // you need to define:
 //
 //   testing::AssertionResult IsEven(const char* expr, int n) {
 //     if ((n % 2) == 0)
 //       return testing::AssertionSuccess();
 //     else
 //       return testing::AssertionFailure()
 //         << "Expected: " << expr << " is even\n  Actual: it's " << n;
 //   }
 //
 // If Foo() returns 5, you will see the following message:
 //
 //   Expected: Foo() is even
 //     Actual: it's 5
 //
 class GTEST_API_ AssertionResult {
  public:
   // Copy constructor.
   // Used in EXPECT_TRUE/FALSE(assertion_result).
   AssertionResult(const AssertionResult& other);
 
 #if defined(_MSC_VER) && _MSC_VER < 1910
   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
 #endif
 
   // Used in the EXPECT_TRUE/FALSE(bool_expression).
   //
   // T must be contextually convertible to bool.
   //
   // The second parameter prevents this overload from being considered if
   // the argument is implicitly convertible to AssertionResult. In that case
   // we want AssertionResult's copy constructor to be used.
   template <typename T>
   explicit AssertionResult(
       const T& success,
       typename internal::EnableIf<
           !std::is_convertible<T, AssertionResult>::value>::type*
       /*enabler*/
       = nullptr)
       : success_(success) {}
 
 #if defined(_MSC_VER) && _MSC_VER < 1910
   GTEST_DISABLE_MSC_WARNINGS_POP_()
 #endif
 
   // Assignment operator.
   AssertionResult& operator=(AssertionResult other) {
     swap(other);
     return *this;
   }
 
   // Returns true iff the assertion succeeded.
   operator bool() const { return success_; }  // NOLINT
 
   // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
   AssertionResult operator!() const;
 
   // Returns the text streamed into this AssertionResult. Test assertions
   // use it when they fail (i.e., the predicate's outcome doesn't match the
   // assertion's expectation). When nothing has been streamed into the
   // object, returns an empty string.
   const char* message() const {
     return message_.get() != nullptr ? message_->c_str() : "";
   }
   // Deprecated; please use message() instead.
   const char* failure_message() const { return message(); }
 
   // Streams a custom failure message into this object.
   template <typename T> AssertionResult& operator<<(const T& value) {
     AppendMessage(Message() << value);
     return *this;
   }
 
   // Allows streaming basic output manipulators such as endl or flush into
   // this object.
   AssertionResult& operator<<(
       ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
     AppendMessage(Message() << basic_manipulator);
     return *this;
   }
 
  private:
   // Appends the contents of message to message_.
   void AppendMessage(const Message& a_message) {
     if (message_.get() == nullptr) message_.reset(new ::std::string);
     message_->append(a_message.GetString().c_str());
   }
 
   // Swap the contents of this AssertionResult with other.
   void swap(AssertionResult& other);
 
   // Stores result of the assertion predicate.
   bool success_;
   // Stores the message describing the condition in case the expectation
   // construct is not satisfied with the predicate's outcome.
   // Referenced via a pointer to avoid taking too much stack frame space
   // with test assertions.
   std::unique_ptr< ::std::string> message_;
 };
 
 // Makes a successful assertion result.
 GTEST_API_ AssertionResult AssertionSuccess();
 
 // Makes a failed assertion result.
 GTEST_API_ AssertionResult AssertionFailure();
 
 // Makes a failed assertion result with the given failure message.
 // Deprecated; use AssertionFailure() << msg.
 GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
 
 }  // namespace testing
 
 // Includes the auto-generated header that implements a family of generic
 // predicate assertion macros. This include comes late because it relies on
 // APIs declared above.
 #include "gtest/gtest_pred_impl.h"
 
 namespace testing {
 
 // The abstract class that all tests inherit from.
 //
 // In Google Test, a unit test program contains one or many TestSuites, and
 // each TestSuite contains one or many Tests.
 //
 // When you define a test using the TEST macro, you don't need to
 // explicitly derive from Test - the TEST macro automatically does
 // this for you.
 //
 // The only time you derive from Test is when defining a test fixture
 // to be used in a TEST_F.  For example:
 //
 //   class FooTest : public testing::Test {
 //    protected:
 //     void SetUp() override { ... }
 //     void TearDown() override { ... }
 //     ...
 //   };
 //
 //   TEST_F(FooTest, Bar) { ... }
 //   TEST_F(FooTest, Baz) { ... }
 //
 // Test is not copyable.
 class GTEST_API_ Test {
  public:
   friend class TestInfo;
 
   // The d'tor is virtual as we intend to inherit from Test.
   virtual ~Test();
 
   // Sets up the stuff shared by all tests in this test case.
   //
   // Google Test will call Foo::SetUpTestSuite() before running the first
   // test in test case Foo.  Hence a sub-class can define its own
   // SetUpTestSuite() method to shadow the one defined in the super
   // class.
   static void SetUpTestSuite() {}
 
   // Tears down the stuff shared by all tests in this test case.
   //
   // Google Test will call Foo::TearDownTestSuite() after running the last
   // test in test case Foo.  Hence a sub-class can define its own
   // TearDownTestSuite() method to shadow the one defined in the super
   // class.
   static void TearDownTestSuite() {}
 
   // Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   static void TearDownTestCase() {}
   static void SetUpTestCase() {}
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   // Returns true iff the current test has a fatal failure.
   static bool HasFatalFailure();
 
   // Returns true iff the current test has a non-fatal failure.
   static bool HasNonfatalFailure();
 
   // Returns true iff the current test was skipped.
   static bool IsSkipped();
 
   // Returns true iff the current test has a (either fatal or
   // non-fatal) failure.
   static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
 
   // Logs a property for the current test, test suite, or for the entire
   // invocation of the test program when used outside of the context of a
   // test suite.  Only the last value for a given key is remembered.  These
   // are public static so they can be called from utility functions that are
   // not members of the test fixture.  Calls to RecordProperty made during
   // lifespan of the test (from the moment its constructor starts to the
   // moment its destructor finishes) will be output in XML as attributes of
   // the <testcase> element.  Properties recorded from fixture's
   // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
   // corresponding <testsuite> element.  Calls to RecordProperty made in the
   // global context (before or after invocation of RUN_ALL_TESTS and from
   // SetUp/TearDown method of Environment objects registered with Google
   // Test) will be output as attributes of the <testsuites> element.
   static void RecordProperty(const std::string& key, const std::string& value);
   static void RecordProperty(const std::string& key, int value);
 
  protected:
   // Creates a Test object.
   Test();
 
   // Sets up the test fixture.
   virtual void SetUp();
 
   // Tears down the test fixture.
   virtual void TearDown();
 
  private:
   // Returns true iff the current test has the same fixture class as
   // the first test in the current test suite.
   static bool HasSameFixtureClass();
 
   // Runs the test after the test fixture has been set up.
   //
   // A sub-class must implement this to define the test logic.
   //
   // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
   // Instead, use the TEST or TEST_F macro.
   virtual void TestBody() = 0;
 
   // Sets up, executes, and tears down the test.
   void Run();
 
   // Deletes self.  We deliberately pick an unusual name for this
   // internal method to avoid clashing with names used in user TESTs.
   void DeleteSelf_() { delete this; }
 
   const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
 
   // Often a user misspells SetUp() as Setup() and spends a long time
   // wondering why it is never called by Google Test.  The declaration of
   // the following method is solely for catching such an error at
   // compile time:
   //
   //   - The return type is deliberately chosen to be not void, so it
   //   will be a conflict if void Setup() is declared in the user's
   //   test fixture.
   //
   //   - This method is private, so it will be another compiler error
   //   if the method is called from the user's test fixture.
   //
   // DO NOT OVERRIDE THIS FUNCTION.
   //
   // If you see an error about overriding the following function or
   // about it being private, you have mis-spelled SetUp() as Setup().
   struct Setup_should_be_spelled_SetUp {};
   virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
 
   // We disallow copying Tests.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
 };
 
 typedef internal::TimeInMillis TimeInMillis;
 
 // A copyable object representing a user specified test property which can be
 // output as a key/value string pair.
 //
 // Don't inherit from TestProperty as its destructor is not virtual.
 class TestProperty {
  public:
   // C'tor.  TestProperty does NOT have a default constructor.
   // Always use this constructor (with parameters) to create a
   // TestProperty object.
   TestProperty(const std::string& a_key, const std::string& a_value) :
     key_(a_key), value_(a_value) {
   }
 
   // Gets the user supplied key.
   const char* key() const {
     return key_.c_str();
   }
 
   // Gets the user supplied value.
   const char* value() const {
     return value_.c_str();
   }
 
   // Sets a new value, overriding the one supplied in the constructor.
   void SetValue(const std::string& new_value) {
     value_ = new_value;
   }
 
  private:
   // The key supplied by the user.
   std::string key_;
   // The value supplied by the user.
   std::string value_;
 };
 
 // The result of a single Test.  This includes a list of
 // TestPartResults, a list of TestProperties, a count of how many
 // death tests there are in the Test, and how much time it took to run
 // the Test.
 //
 // TestResult is not copyable.
 class GTEST_API_ TestResult {
  public:
   // Creates an empty TestResult.
   TestResult();
 
   // D'tor.  Do not inherit from TestResult.
   ~TestResult();
 
   // Gets the number of all test parts.  This is the sum of the number
   // of successful test parts and the number of failed test parts.
   int total_part_count() const;
 
   // Returns the number of the test properties.
   int test_property_count() const;
 
   // Returns true iff the test passed (i.e. no test part failed).
   bool Passed() const { return !Skipped() && !Failed(); }
 
   // Returns true iff the test was skipped.
   bool Skipped() const;
 
   // Returns true iff the test failed.
   bool Failed() const;
 
   // Returns true iff the test fatally failed.
   bool HasFatalFailure() const;
 
   // Returns true iff the test has a non-fatal failure.
   bool HasNonfatalFailure() const;
 
   // Returns the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
   // Returns the i-th test part result among all the results. i can range from 0
   // to total_part_count() - 1. If i is not in that range, aborts the program.
   const TestPartResult& GetTestPartResult(int i) const;
 
   // Returns the i-th test property. i can range from 0 to
   // test_property_count() - 1. If i is not in that range, aborts the
   // program.
   const TestProperty& GetTestProperty(int i) const;
 
  private:
   friend class TestInfo;
   friend class TestSuite;
   friend class UnitTest;
   friend class internal::DefaultGlobalTestPartResultReporter;
   friend class internal::ExecDeathTest;
   friend class internal::TestResultAccessor;
   friend class internal::UnitTestImpl;
   friend class internal::WindowsDeathTest;
   friend class internal::FuchsiaDeathTest;
 
   // Gets the vector of TestPartResults.
   const std::vector<TestPartResult>& test_part_results() const {
     return test_part_results_;
   }
 
   // Gets the vector of TestProperties.
   const std::vector<TestProperty>& test_properties() const {
     return test_properties_;
   }
 
   // Sets the elapsed time.
   void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
 
   // Adds a test property to the list. The property is validated and may add
   // a non-fatal failure if invalid (e.g., if it conflicts with reserved
   // key names). If a property is already recorded for the same key, the
   // value will be updated, rather than storing multiple values for the same
   // key.  xml_element specifies the element for which the property is being
   // recorded and is used for validation.
   void RecordProperty(const std::string& xml_element,
                       const TestProperty& test_property);
 
   // Adds a failure if the key is a reserved attribute of Google Test
   // testsuite tags.  Returns true if the property is valid.
   // FIXME: Validate attribute names are legal and human readable.
   static bool ValidateTestProperty(const std::string& xml_element,
                                    const TestProperty& test_property);
 
   // Adds a test part result to the list.
   void AddTestPartResult(const TestPartResult& test_part_result);
 
   // Returns the death test count.
   int death_test_count() const { return death_test_count_; }
 
   // Increments the death test count, returning the new count.
   int increment_death_test_count() { return ++death_test_count_; }
 
   // Clears the test part results.
   void ClearTestPartResults();
 
   // Clears the object.
   void Clear();
 
   // Protects mutable state of the property vector and of owned
   // properties, whose values may be updated.
   internal::Mutex test_properites_mutex_;
 
   // The vector of TestPartResults
   std::vector<TestPartResult> test_part_results_;
   // The vector of TestProperties
   std::vector<TestProperty> test_properties_;
   // Running count of death tests.
   int death_test_count_;
   // The elapsed time, in milliseconds.
   TimeInMillis elapsed_time_;
 
   // We disallow copying TestResult.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
 };  // class TestResult
 
 // A TestInfo object stores the following information about a test:
 //
 //   Test suite name
 //   Test name
 //   Whether the test should be run
 //   A function pointer that creates the test object when invoked
 //   Test result
 //
 // The constructor of TestInfo registers itself with the UnitTest
 // singleton such that the RUN_ALL_TESTS() macro knows which tests to
 // run.
 class GTEST_API_ TestInfo {
  public:
   // Destructs a TestInfo object.  This function is not virtual, so
   // don't inherit from TestInfo.
   ~TestInfo();
 
   // Returns the test suite name.
   const char* test_suite_name() const { return test_suite_name_.c_str(); }
 
 // Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   const char* test_case_name() const { return test_suite_name(); }
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   // Returns the test name.
   const char* name() const { return name_.c_str(); }
 
   // Returns the name of the parameter type, or NULL if this is not a typed
   // or a type-parameterized test.
   const char* type_param() const {
     if (type_param_.get() != nullptr) return type_param_->c_str();
     return nullptr;
   }
 
   // Returns the text representation of the value parameter, or NULL if this
   // is not a value-parameterized test.
   const char* value_param() const {
     if (value_param_.get() != nullptr) return value_param_->c_str();
     return nullptr;
   }
 
   // Returns the file name where this test is defined.
   const char* file() const { return location_.file.c_str(); }
 
   // Returns the line where this test is defined.
   int line() const { return location_.line; }
 
   // Return true if this test should not be run because it's in another shard.
   bool is_in_another_shard() const { return is_in_another_shard_; }
 
   // Returns true if this test should run, that is if the test is not
   // disabled (or it is disabled but the also_run_disabled_tests flag has
   // been specified) and its full name matches the user-specified filter.
   //
   // Google Test allows the user to filter the tests by their full names.
   // The full name of a test Bar in test suite Foo is defined as
   // "Foo.Bar".  Only the tests that match the filter will run.
   //
   // A filter is a colon-separated list of glob (not regex) patterns,
   // optionally followed by a '-' and a colon-separated list of
   // negative patterns (tests to exclude).  A test is run if it
   // matches one of the positive patterns and does not match any of
   // the negative patterns.
   //
   // For example, *A*:Foo.* is a filter that matches any string that
   // contains the character 'A' or starts with "Foo.".
   bool should_run() const { return should_run_; }
 
   // Returns true iff this test will appear in the XML report.
   bool is_reportable() const {
     // The XML report includes tests matching the filter, excluding those
     // run in other shards.
     return matches_filter_ && !is_in_another_shard_;
   }
 
   // Returns the result of the test.
   const TestResult* result() const { return &result_; }
 
  private:
 #if GTEST_HAS_DEATH_TEST
   friend class internal::DefaultDeathTestFactory;
 #endif  // GTEST_HAS_DEATH_TEST
   friend class Test;
   friend class TestSuite;
   friend class internal::UnitTestImpl;
   friend class internal::StreamingListenerTest;
   friend TestInfo* internal::MakeAndRegisterTestInfo(
       const char* test_suite_name, const char* name, const char* type_param,
       const char* value_param, internal::CodeLocation code_location,
       internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
       internal::TearDownTestSuiteFunc tear_down_tc,
       internal::TestFactoryBase* factory);
 
   // Constructs a TestInfo object. The newly constructed instance assumes
   // ownership of the factory object.
   TestInfo(const std::string& test_suite_name, const std::string& name,
            const char* a_type_param,   // NULL if not a type-parameterized test
            const char* a_value_param,  // NULL if not a value-parameterized test
            internal::CodeLocation a_code_location,
            internal::TypeId fixture_class_id,
            internal::TestFactoryBase* factory);
 
   // Increments the number of death tests encountered in this test so
   // far.
   int increment_death_test_count() {
     return result_.increment_death_test_count();
   }
 
   // Creates the test object, runs it, records its result, and then
   // deletes it.
   void Run();
 
   static void ClearTestResult(TestInfo* test_info) {
     test_info->result_.Clear();
   }
 
   // These fields are immutable properties of the test.
   const std::string test_suite_name_;    // test suite name
   const std::string name_;               // Test name
   // Name of the parameter type, or NULL if this is not a typed or a
   // type-parameterized test.
   const std::unique_ptr<const ::std::string> type_param_;
   // Text representation of the value parameter, or NULL if this is not a
   // value-parameterized test.
   const std::unique_ptr<const ::std::string> value_param_;
   internal::CodeLocation location_;
   const internal::TypeId fixture_class_id_;   // ID of the test fixture class
   bool should_run_;                 // True iff this test should run
   bool is_disabled_;                // True iff this test is disabled
   bool matches_filter_;             // True if this test matches the
                                     // user-specified filter.
   bool is_in_another_shard_;        // Will be run in another shard.
   internal::TestFactoryBase* const factory_;  // The factory that creates
                                               // the test object
 
   // This field is mutable and needs to be reset before running the
   // test for the second time.
   TestResult result_;
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
 };
 
 // A test suite, which consists of a vector of TestInfos.
 //
 // TestSuite is not copyable.
 class GTEST_API_ TestSuite {
  public:
   // Creates a TestSuite with the given name.
   //
   // TestSuite does NOT have a default constructor.  Always use this
   // constructor to create a TestSuite object.
   //
   // Arguments:
   //
   //   name:         name of the test suite
   //   a_type_param: the name of the test's type parameter, or NULL if
   //                 this is not a type-parameterized test.
   //   set_up_tc:    pointer to the function that sets up the test suite
   //   tear_down_tc: pointer to the function that tears down the test suite
   TestSuite(const char* name, const char* a_type_param,
             internal::SetUpTestSuiteFunc set_up_tc,
             internal::TearDownTestSuiteFunc tear_down_tc);
 
   // Destructor of TestSuite.
   virtual ~TestSuite();
 
   // Gets the name of the TestSuite.
   const char* name() const { return name_.c_str(); }
 
   // Returns the name of the parameter type, or NULL if this is not a
   // type-parameterized test suite.
   const char* type_param() const {
     if (type_param_.get() != nullptr) return type_param_->c_str();
     return nullptr;
   }
 
   // Returns true if any test in this test suite should run.
   bool should_run() const { return should_run_; }
 
   // Gets the number of successful tests in this test suite.
   int successful_test_count() const;
 
   // Gets the number of skipped tests in this test suite.
   int skipped_test_count() const;
 
   // Gets the number of failed tests in this test suite.
   int failed_test_count() const;
 
   // Gets the number of disabled tests that will be reported in the XML report.
   int reportable_disabled_test_count() const;
 
   // Gets the number of disabled tests in this test suite.
   int disabled_test_count() const;
 
   // Gets the number of tests to be printed in the XML report.
   int reportable_test_count() const;
 
   // Get the number of tests in this test suite that should run.
   int test_to_run_count() const;
 
   // Gets the number of all tests in this test suite.
   int total_test_count() const;
 
   // Returns true iff the test suite passed.
   bool Passed() const { return !Failed(); }
 
   // Returns true iff the test suite failed.
   bool Failed() const { return failed_test_count() > 0; }
 
   // Returns the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
   // Returns the i-th test among all the tests. i can range from 0 to
   // total_test_count() - 1. If i is not in that range, returns NULL.
   const TestInfo* GetTestInfo(int i) const;
 
   // Returns the TestResult that holds test properties recorded during
   // execution of SetUpTestSuite and TearDownTestSuite.
   const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
 
  private:
   friend class Test;
   friend class internal::UnitTestImpl;
 
   // Gets the (mutable) vector of TestInfos in this TestSuite.
   std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
 
   // Gets the (immutable) vector of TestInfos in this TestSuite.
   const std::vector<TestInfo*>& test_info_list() const {
     return test_info_list_;
   }
 
   // Returns the i-th test among all the tests. i can range from 0 to
   // total_test_count() - 1. If i is not in that range, returns NULL.
   TestInfo* GetMutableTestInfo(int i);
 
   // Sets the should_run member.
   void set_should_run(bool should) { should_run_ = should; }
 
   // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
   // destruction of the TestSuite object.
   void AddTestInfo(TestInfo * test_info);
 
   // Clears the results of all tests in this test suite.
   void ClearResult();
 
   // Clears the results of all tests in the given test suite.
   static void ClearTestSuiteResult(TestSuite* test_suite) {
     test_suite->ClearResult();
   }
 
   // Runs every test in this TestSuite.
   void Run();
 
   // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
   // for catching exceptions thrown from SetUpTestSuite().
   void RunSetUpTestSuite() {
     if (set_up_tc_ != nullptr) {
       (*set_up_tc_)();
     }
   }
 
   // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
   // needed for catching exceptions thrown from TearDownTestSuite().
   void RunTearDownTestSuite() {
     if (tear_down_tc_ != nullptr) {
       (*tear_down_tc_)();
     }
   }
 
   // Returns true iff test passed.
   static bool TestPassed(const TestInfo* test_info) {
     return test_info->should_run() && test_info->result()->Passed();
   }
 
   // Returns true iff test skipped.
   static bool TestSkipped(const TestInfo* test_info) {
     return test_info->should_run() && test_info->result()->Skipped();
   }
 
   // Returns true iff test failed.
   static bool TestFailed(const TestInfo* test_info) {
     return test_info->should_run() && test_info->result()->Failed();
   }
 
   // Returns true iff the test is disabled and will be reported in the XML
   // report.
   static bool TestReportableDisabled(const TestInfo* test_info) {
     return test_info->is_reportable() && test_info->is_disabled_;
   }
 
   // Returns true iff test is disabled.
   static bool TestDisabled(const TestInfo* test_info) {
     return test_info->is_disabled_;
   }
 
   // Returns true iff this test will appear in the XML report.
   static bool TestReportable(const TestInfo* test_info) {
     return test_info->is_reportable();
   }
 
   // Returns true if the given test should run.
   static bool ShouldRunTest(const TestInfo* test_info) {
     return test_info->should_run();
   }
 
   // Shuffles the tests in this test suite.
   void ShuffleTests(internal::Random* random);
 
   // Restores the test order to before the first shuffle.
   void UnshuffleTests();
 
   // Name of the test suite.
   std::string name_;
   // Name of the parameter type, or NULL if this is not a typed or a
   // type-parameterized test.
   const std::unique_ptr<const ::std::string> type_param_;
   // The vector of TestInfos in their original order.  It owns the
   // elements in the vector.
   std::vector<TestInfo*> test_info_list_;
   // Provides a level of indirection for the test list to allow easy
   // shuffling and restoring the test order.  The i-th element in this
   // vector is the index of the i-th test in the shuffled test list.
   std::vector<int> test_indices_;
   // Pointer to the function that sets up the test suite.
   internal::SetUpTestSuiteFunc set_up_tc_;
   // Pointer to the function that tears down the test suite.
   internal::TearDownTestSuiteFunc tear_down_tc_;
   // True iff any test in this test suite should run.
   bool should_run_;
   // Elapsed time, in milliseconds.
   TimeInMillis elapsed_time_;
   // Holds test properties recorded during execution of SetUpTestSuite and
   // TearDownTestSuite.
   TestResult ad_hoc_test_result_;
 
   // We disallow copying TestSuites.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
 };
 
 // An Environment object is capable of setting up and tearing down an
 // environment.  You should subclass this to define your own
 // environment(s).
 //
 // An Environment object does the set-up and tear-down in virtual
 // methods SetUp() and TearDown() instead of the constructor and the
 // destructor, as:
 //
 //   1. You cannot safely throw from a destructor.  This is a problem
 //      as in some cases Google Test is used where exceptions are enabled, and
 //      we may want to implement ASSERT_* using exceptions where they are
 //      available.
 //   2. You cannot use ASSERT_* directly in a constructor or
 //      destructor.
 class Environment {
  public:
   // The d'tor is virtual as we need to subclass Environment.
   virtual ~Environment() {}
 
   // Override this to define how to set up the environment.
   virtual void SetUp() {}
 
   // Override this to define how to tear down the environment.
   virtual void TearDown() {}
  private:
   // If you see an error about overriding the following function or
   // about it being private, you have mis-spelled SetUp() as Setup().
   struct Setup_should_be_spelled_SetUp {};
   virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
 };
 
 #if GTEST_HAS_EXCEPTIONS
 
 // Exception which can be thrown from TestEventListener::OnTestPartResult.
 class GTEST_API_ AssertionException
     : public internal::GoogleTestFailureException {
  public:
   explicit AssertionException(const TestPartResult& result)
       : GoogleTestFailureException(result) {}
 };
 
 #endif  // GTEST_HAS_EXCEPTIONS
 
 // The interface for tracing execution of tests. The methods are organized in
 // the order the corresponding events are fired.
 class TestEventListener {
  public:
   virtual ~TestEventListener() {}
 
   // Fired before any test activity starts.
   virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
 
   // Fired before each iteration of tests starts.  There may be more than
   // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
   // index, starting from 0.
   virtual void OnTestIterationStart(const UnitTest& unit_test,
                                     int iteration) = 0;
 
   // Fired before environment set-up for each iteration of tests starts.
   virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
 
   // Fired after environment set-up for each iteration of tests ends.
   virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
 
   // Fired before the test suite starts.
-  virtual void OnTestSuiteStart(const TestSuite& test_suite) {}
+  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
 
   //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseStart(const TestCase& test_case) {}
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   // Fired before the test starts.
   virtual void OnTestStart(const TestInfo& test_info) = 0;
 
   // Fired after a failed assertion or a SUCCEED() invocation.
   // If you want to throw an exception from this function to skip to the next
   // TEST, it must be AssertionException defined above, or inherited from it.
   virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
 
   // Fired after the test ends.
   virtual void OnTestEnd(const TestInfo& test_info) = 0;
 
   // Fired after the test suite ends.
-  virtual void OnTestSuiteEnd(const TestSuite& test_suite) {}
+  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
 
 //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseEnd(const TestCase& test_case) {}
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   // Fired before environment tear-down for each iteration of tests starts.
   virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
 
   // Fired after environment tear-down for each iteration of tests ends.
   virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
 
   // Fired after each iteration of tests finishes.
   virtual void OnTestIterationEnd(const UnitTest& unit_test,
                                   int iteration) = 0;
 
   // Fired after all test activities have ended.
   virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
 };
 
 // The convenience class for users who need to override just one or two
 // methods and are not concerned that a possible change to a signature of
 // the methods they override will not be caught during the build.  For
 // comments about each method please see the definition of TestEventListener
 // above.
 class EmptyTestEventListener : public TestEventListener {
  public:
   void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
   void OnTestIterationStart(const UnitTest& /*unit_test*/,
                             int /*iteration*/) override {}
   void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
   void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
   void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
 //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseStart(const TestCase& tc /*test_suite*/) override {}
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   void OnTestStart(const TestInfo& /*test_info*/) override {}
   void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
   void OnTestEnd(const TestInfo& /*test_info*/) override {}
   void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseEnd(const TestCase& tc /*test_suite*/) override {}
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
   void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
   void OnTestIterationEnd(const UnitTest& /*unit_test*/,
                           int /*iteration*/) override {}
   void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
 };
 
 // TestEventListeners lets users add listeners to track events in Google Test.
 class GTEST_API_ TestEventListeners {
  public:
   TestEventListeners();
   ~TestEventListeners();
 
   // Appends an event listener to the end of the list. Google Test assumes
   // the ownership of the listener (i.e. it will delete the listener when
   // the test program finishes).
   void Append(TestEventListener* listener);
 
   // Removes the given event listener from the list and returns it.  It then
   // becomes the caller's responsibility to delete the listener. Returns
   // NULL if the listener is not found in the list.
   TestEventListener* Release(TestEventListener* listener);
 
   // Returns the standard listener responsible for the default console
   // output.  Can be removed from the listeners list to shut down default
   // console output.  Note that removing this object from the listener list
   // with Release transfers its ownership to the caller and makes this
   // function return NULL the next time.
   TestEventListener* default_result_printer() const {
     return default_result_printer_;
   }
 
   // Returns the standard listener responsible for the default XML output
   // controlled by the --gtest_output=xml flag.  Can be removed from the
   // listeners list by users who want to shut down the default XML output
   // controlled by this flag and substitute it with custom one.  Note that
   // removing this object from the listener list with Release transfers its
   // ownership to the caller and makes this function return NULL the next
   // time.
   TestEventListener* default_xml_generator() const {
     return default_xml_generator_;
   }
 
  private:
   friend class TestSuite;
   friend class TestInfo;
   friend class internal::DefaultGlobalTestPartResultReporter;
   friend class internal::NoExecDeathTest;
   friend class internal::TestEventListenersAccessor;
   friend class internal::UnitTestImpl;
 
   // Returns repeater that broadcasts the TestEventListener events to all
   // subscribers.
   TestEventListener* repeater();
 
   // Sets the default_result_printer attribute to the provided listener.
   // The listener is also added to the listener list and previous
   // default_result_printer is removed from it and deleted. The listener can
   // also be NULL in which case it will not be added to the list. Does
   // nothing if the previous and the current listener objects are the same.
   void SetDefaultResultPrinter(TestEventListener* listener);
 
   // Sets the default_xml_generator attribute to the provided listener.  The
   // listener is also added to the listener list and previous
   // default_xml_generator is removed from it and deleted. The listener can
   // also be NULL in which case it will not be added to the list. Does
   // nothing if the previous and the current listener objects are the same.
   void SetDefaultXmlGenerator(TestEventListener* listener);
 
   // Controls whether events will be forwarded by the repeater to the
   // listeners in the list.
   bool EventForwardingEnabled() const;
   void SuppressEventForwarding();
 
   // The actual list of listeners.
   internal::TestEventRepeater* repeater_;
   // Listener responsible for the standard result output.
   TestEventListener* default_result_printer_;
   // Listener responsible for the creation of the XML output file.
   TestEventListener* default_xml_generator_;
 
   // We disallow copying TestEventListeners.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
 };
 
 // A UnitTest consists of a vector of TestSuites.
 //
 // This is a singleton class.  The only instance of UnitTest is
 // created when UnitTest::GetInstance() is first called.  This
 // instance is never deleted.
 //
 // UnitTest is not copyable.
 //
 // This class is thread-safe as long as the methods are called
 // according to their specification.
 class GTEST_API_ UnitTest {
  public:
   // Gets the singleton UnitTest object.  The first time this method
   // is called, a UnitTest object is constructed and returned.
   // Consecutive calls will return the same object.
   static UnitTest* GetInstance();
 
   // Runs all tests in this UnitTest object and prints the result.
   // Returns 0 if successful, or 1 otherwise.
   //
   // This method can only be called from the main thread.
   //
   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
   int Run() GTEST_MUST_USE_RESULT_;
 
   // Returns the working directory when the first TEST() or TEST_F()
   // was executed.  The UnitTest object owns the string.
   const char* original_working_dir() const;
 
   // Returns the TestSuite object for the test that's currently running,
   // or NULL if no test is running.
   const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
 
 // Legacy API is still available but deprecated
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
 #endif
 
   // Returns the TestInfo object for the test that's currently running,
   // or NULL if no test is running.
   const TestInfo* current_test_info() const
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Returns the random seed used at the start of the current test run.
   int random_seed() const;
 
   // Returns the ParameterizedTestSuiteRegistry object used to keep track of
   // value-parameterized tests and instantiate and register them.
   //
   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
   internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Gets the number of successful test suites.
   int successful_test_suite_count() const;
 
   // Gets the number of failed test suites.
   int failed_test_suite_count() const;
 
   // Gets the number of all test suites.
   int total_test_suite_count() const;
 
   // Gets the number of all test suites that contain at least one test
   // that should run.
   int test_suite_to_run_count() const;
 
   //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   int successful_test_case_count() const;
   int failed_test_case_count() const;
   int total_test_case_count() const;
   int test_case_to_run_count() const;
 #endif  //  EMOVE_LEGACY_TEST_CASEAPI
 
   // Gets the number of successful tests.
   int successful_test_count() const;
 
   // Gets the number of skipped tests.
   int skipped_test_count() const;
 
   // Gets the number of failed tests.
   int failed_test_count() const;
 
   // Gets the number of disabled tests that will be reported in the XML report.
   int reportable_disabled_test_count() const;
 
   // Gets the number of disabled tests.
   int disabled_test_count() const;
 
   // Gets the number of tests to be printed in the XML report.
   int reportable_test_count() const;
 
   // Gets the number of all tests.
   int total_test_count() const;
 
   // Gets the number of tests that should run.
   int test_to_run_count() const;
 
   // Gets the time of the test program start, in ms from the start of the
   // UNIX epoch.
   TimeInMillis start_timestamp() const;
 
   // Gets the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const;
 
   // Returns true iff the unit test passed (i.e. all test suites passed).
   bool Passed() const;
 
   // Returns true iff the unit test failed (i.e. some test suite failed
   // or something outside of all tests failed).
   bool Failed() const;
 
   // Gets the i-th test suite among all the test suites. i can range from 0 to
   // total_test_suite_count() - 1. If i is not in that range, returns NULL.
   const TestSuite* GetTestSuite(int i) const;
 
 //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
   const TestCase* GetTestCase(int i) const;
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
   // Returns the TestResult containing information on test failures and
   // properties logged outside of individual test suites.
   const TestResult& ad_hoc_test_result() const;
 
   // Returns the list of event listeners that can be used to track events
   // inside Google Test.
   TestEventListeners& listeners();
 
  private:
   // Registers and returns a global test environment.  When a test
   // program is run, all global test environments will be set-up in
   // the order they were registered.  After all tests in the program
   // have finished, all global test environments will be torn-down in
   // the *reverse* order they were registered.
   //
   // The UnitTest object takes ownership of the given environment.
   //
   // This method can only be called from the main thread.
   Environment* AddEnvironment(Environment* env);
 
   // Adds a TestPartResult to the current TestResult object.  All
   // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
   // eventually call this to report their results.  The user code
   // should use the assertion macros instead of calling this directly.
   void AddTestPartResult(TestPartResult::Type result_type,
                          const char* file_name,
                          int line_number,
                          const std::string& message,
                          const std::string& os_stack_trace)
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Adds a TestProperty to the current TestResult object when invoked from
   // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
   // from SetUpTestSuite or TearDownTestSuite, or to the global property set
   // when invoked elsewhere.  If the result already contains a property with
   // the same key, the value will be updated.
   void RecordProperty(const std::string& key, const std::string& value);
 
   // Gets the i-th test suite among all the test suites. i can range from 0 to
   // total_test_suite_count() - 1. If i is not in that range, returns NULL.
   TestSuite* GetMutableTestSuite(int i);
 
   // Accessors for the implementation object.
   internal::UnitTestImpl* impl() { return impl_; }
   const internal::UnitTestImpl* impl() const { return impl_; }
 
   // These classes and functions are friends as they need to access private
   // members of UnitTest.
   friend class ScopedTrace;
   friend class Test;
   friend class internal::AssertHelper;
   friend class internal::StreamingListenerTest;
   friend class internal::UnitTestRecordPropertyTestHelper;
   friend Environment* AddGlobalTestEnvironment(Environment* env);
   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
   friend void internal::ReportFailureInUnknownLocation(
       TestPartResult::Type result_type,
       const std::string& message);
 
   // Creates an empty UnitTest.
   UnitTest();
 
   // D'tor
   virtual ~UnitTest();
 
   // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
   // Google Test trace stack.
   void PushGTestTrace(const internal::TraceInfo& trace)
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Pops a trace from the per-thread Google Test trace stack.
   void PopGTestTrace()
       GTEST_LOCK_EXCLUDED_(mutex_);
 
   // Protects mutable state in *impl_.  This is mutable as some const
   // methods need to lock it too.
   mutable internal::Mutex mutex_;
 
   // Opaque implementation object.  This field is never changed once
   // the object is constructed.  We don't mark it as const here, as
   // doing so will cause a warning in the constructor of UnitTest.
   // Mutable state in *impl_ is protected by mutex_.
   internal::UnitTestImpl* impl_;
 
   // We disallow copying UnitTest.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
 };
 
 // A convenient wrapper for adding an environment for the test
 // program.
 //
 // You should call this before RUN_ALL_TESTS() is called, probably in
 // main().  If you use gtest_main, you need to call this before main()
 // starts for it to take effect.  For example, you can define a global
 // variable like this:
 //
 //   testing::Environment* const foo_env =
 //       testing::AddGlobalTestEnvironment(new FooEnvironment);
 //
 // However, we strongly recommend you to write your own main() and
 // call AddGlobalTestEnvironment() there, as relying on initialization
 // of global variables makes the code harder to read and may cause
 // problems when you register multiple environments from different
 // translation units and the environments have dependencies among them
 // (remember that the compiler doesn't guarantee the order in which
 // global variables from different translation units are initialized).
 inline Environment* AddGlobalTestEnvironment(Environment* env) {
   return UnitTest::GetInstance()->AddEnvironment(env);
 }
 
 // Initializes Google Test.  This must be called before calling
 // RUN_ALL_TESTS().  In particular, it parses a command line for the
 // flags that Google Test recognizes.  Whenever a Google Test flag is
 // seen, it is removed from argv, and *argc is decremented.
 //
 // No value is returned.  Instead, the Google Test flag variables are
 // updated.
 //
 // Calling the function for the second time has no user-visible effect.
 GTEST_API_ void InitGoogleTest(int* argc, char** argv);
 
 // This overloaded version can be used in Windows programs compiled in
 // UNICODE mode.
 GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
 
 namespace internal {
 
 // Separate the error generating code from the code path to reduce the stack
 // frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
 // when calling EXPECT_* in a tight loop.
 template <typename T1, typename T2>
 AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                                    const char* rhs_expression,
                                    const T1& lhs, const T2& rhs) {
   return EqFailure(lhs_expression,
                    rhs_expression,
                    FormatForComparisonFailureMessage(lhs, rhs),
                    FormatForComparisonFailureMessage(rhs, lhs),
                    false);
 }
 
 // This block of code defines operator==/!=
 // to block lexical scope lookup.
 // It prevents using invalid operator==/!= defined at namespace scope.
 struct faketype {};
 inline bool operator==(faketype, faketype) { return true; }
 inline bool operator!=(faketype, faketype) { return false; }
 
 // The helper function for {ASSERT|EXPECT}_EQ.
 template <typename T1, typename T2>
 AssertionResult CmpHelperEQ(const char* lhs_expression,
                             const char* rhs_expression,
                             const T1& lhs,
                             const T2& rhs) {
   if (lhs == rhs) {
     return AssertionSuccess();
   }
 
   return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
 }
 
 // With this overloaded version, we allow anonymous enums to be used
 // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
 // can be implicitly cast to BiggestInt.
 GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
                                        const char* rhs_expression,
                                        BiggestInt lhs,
                                        BiggestInt rhs);
 
 // The helper class for {ASSERT|EXPECT}_EQ.  The template argument
 // lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
 // is a null pointer literal.  The following default implementation is
 // for lhs_is_null_literal being false.
 template <bool lhs_is_null_literal>
 class EqHelper {
  public:
   // This templatized version is for the general case.
   template <typename T1, typename T2>
   static AssertionResult Compare(const char* lhs_expression,
                                  const char* rhs_expression,
                                  const T1& lhs,
                                  const T2& rhs) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
 
   // With this overloaded version, we allow anonymous enums to be used
   // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
   // enums can be implicitly cast to BiggestInt.
   //
   // Even though its body looks the same as the above version, we
   // cannot merge the two, as it will make anonymous enums unhappy.
   static AssertionResult Compare(const char* lhs_expression,
                                  const char* rhs_expression,
                                  BiggestInt lhs,
                                  BiggestInt rhs) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
 };
 
 // This specialization is used when the first argument to ASSERT_EQ()
 // is a null pointer literal, like NULL, false, or 0.
 template <>
 class EqHelper<true> {
  public:
   // We define two overloaded versions of Compare().  The first
   // version will be picked when the second argument to ASSERT_EQ() is
   // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
   // EXPECT_EQ(false, a_bool).
   template <typename T1, typename T2>
   static AssertionResult Compare(
       const char* lhs_expression, const char* rhs_expression, const T1& lhs,
       const T2& rhs,
       // The following line prevents this overload from being considered if T2
       // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
       // expands to Compare("", "", NULL, my_ptr), which requires a conversion
       // to match the Secret* in the other overload, which would otherwise make
       // this template match better.
       typename EnableIf<!std::is_pointer<T2>::value>::type* = nullptr) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
 
   // This version will be picked when the second argument to ASSERT_EQ() is a
   // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
   template <typename T>
   static AssertionResult Compare(
       const char* lhs_expression,
       const char* rhs_expression,
       // We used to have a second template parameter instead of Secret*.  That
       // template parameter would deduce to 'long', making this a better match
       // than the first overload even without the first overload's EnableIf.
       // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
       // non-pointer argument" (even a deduced integral argument), so the old
       // implementation caused warnings in user code.
       Secret* /* lhs (NULL) */,
       T* rhs) {
     // We already know that 'lhs' is a null pointer.
     return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
                        rhs);
   }
 };
 
 // Separate the error generating code from the code path to reduce the stack
 // frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
 // when calling EXPECT_OP in a tight loop.
 template <typename T1, typename T2>
 AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                    const T1& val1, const T2& val2,
                                    const char* op) {
   return AssertionFailure()
          << "Expected: (" << expr1 << ") " << op << " (" << expr2
          << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
          << " vs " << FormatForComparisonFailureMessage(val2, val1);
 }
 
 // A macro for implementing the helper functions needed to implement
 // ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
 // of similar code.
 //
 // For each templatized helper function, we also define an overloaded
 // version for BiggestInt in order to reduce code bloat and allow
 // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
 // with gcc 4.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
 #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
 template <typename T1, typename T2>\
 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                    const T1& val1, const T2& val2) {\
   if (val1 op val2) {\
     return AssertionSuccess();\
   } else {\
     return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
   }\
 }\
 GTEST_API_ AssertionResult CmpHelper##op_name(\
     const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
 // Implements the helper function for {ASSERT|EXPECT}_NE
 GTEST_IMPL_CMP_HELPER_(NE, !=);
 // Implements the helper function for {ASSERT|EXPECT}_LE
 GTEST_IMPL_CMP_HELPER_(LE, <=);
 // Implements the helper function for {ASSERT|EXPECT}_LT
 GTEST_IMPL_CMP_HELPER_(LT, <);
 // Implements the helper function for {ASSERT|EXPECT}_GE
 GTEST_IMPL_CMP_HELPER_(GE, >=);
 // Implements the helper function for {ASSERT|EXPECT}_GT
 GTEST_IMPL_CMP_HELPER_(GT, >);
 
 #undef GTEST_IMPL_CMP_HELPER_
 
 // The helper function for {ASSERT|EXPECT}_STREQ.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                           const char* s2_expression,
                                           const char* s1,
                                           const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
                                               const char* s2_expression,
                                               const char* s1,
                                               const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRNE.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                           const char* s2_expression,
                                           const char* s1,
                                           const char* s2);
 
 // The helper function for {ASSERT|EXPECT}_STRCASENE.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                               const char* s2_expression,
                                               const char* s1,
                                               const char* s2);
 
 
 // Helper function for *_STREQ on wide strings.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
                                           const char* s2_expression,
                                           const wchar_t* s1,
                                           const wchar_t* s2);
 
 // Helper function for *_STRNE on wide strings.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                           const char* s2_expression,
                                           const wchar_t* s1,
                                           const wchar_t* s2);
 
 }  // namespace internal
 
 // IsSubstring() and IsNotSubstring() are intended to be used as the
 // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
 // themselves.  They check whether needle is a substring of haystack
 // (NULL is considered a substring of itself only), and return an
 // appropriate error message when they fail.
 //
 // The {needle,haystack}_expr arguments are the stringified
 // expressions that generated the two real arguments.
 GTEST_API_ AssertionResult IsSubstring(
     const char* needle_expr, const char* haystack_expr,
     const char* needle, const char* haystack);
 GTEST_API_ AssertionResult IsSubstring(
     const char* needle_expr, const char* haystack_expr,
     const wchar_t* needle, const wchar_t* haystack);
 GTEST_API_ AssertionResult IsNotSubstring(
     const char* needle_expr, const char* haystack_expr,
     const char* needle, const char* haystack);
 GTEST_API_ AssertionResult IsNotSubstring(
     const char* needle_expr, const char* haystack_expr,
     const wchar_t* needle, const wchar_t* haystack);
 GTEST_API_ AssertionResult IsSubstring(
     const char* needle_expr, const char* haystack_expr,
     const ::std::string& needle, const ::std::string& haystack);
 GTEST_API_ AssertionResult IsNotSubstring(
     const char* needle_expr, const char* haystack_expr,
     const ::std::string& needle, const ::std::string& haystack);
 
 #if GTEST_HAS_STD_WSTRING
 GTEST_API_ AssertionResult IsSubstring(
     const char* needle_expr, const char* haystack_expr,
     const ::std::wstring& needle, const ::std::wstring& haystack);
 GTEST_API_ AssertionResult IsNotSubstring(
     const char* needle_expr, const char* haystack_expr,
     const ::std::wstring& needle, const ::std::wstring& haystack);
 #endif  // GTEST_HAS_STD_WSTRING
 
 namespace internal {
 
 // Helper template function for comparing floating-points.
 //
 // Template parameter:
 //
 //   RawType: the raw floating-point type (either float or double)
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 template <typename RawType>
 AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
                                          const char* rhs_expression,
                                          RawType lhs_value,
                                          RawType rhs_value) {
   const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
 
   if (lhs.AlmostEquals(rhs)) {
     return AssertionSuccess();
   }
 
   ::std::stringstream lhs_ss;
   lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << lhs_value;
 
   ::std::stringstream rhs_ss;
   rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
          << rhs_value;
 
   return EqFailure(lhs_expression,
                    rhs_expression,
                    StringStreamToString(&lhs_ss),
                    StringStreamToString(&rhs_ss),
                    false);
 }
 
 // Helper function for implementing ASSERT_NEAR.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
                                                 const char* expr2,
                                                 const char* abs_error_expr,
                                                 double val1,
                                                 double val2,
                                                 double abs_error);
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 // A class that enables one to stream messages to assertion macros
 class GTEST_API_ AssertHelper {
  public:
   // Constructor.
   AssertHelper(TestPartResult::Type type,
                const char* file,
                int line,
                const char* message);
   ~AssertHelper();
 
   // Message assignment is a semantic trick to enable assertion
   // streaming; see the GTEST_MESSAGE_ macro below.
   void operator=(const Message& message) const;
 
  private:
   // We put our data in a struct so that the size of the AssertHelper class can
   // be as small as possible.  This is important because gcc is incapable of
   // re-using stack space even for temporary variables, so every EXPECT_EQ
   // reserves stack space for another AssertHelper.
   struct AssertHelperData {
     AssertHelperData(TestPartResult::Type t,
                      const char* srcfile,
                      int line_num,
                      const char* msg)
         : type(t), file(srcfile), line(line_num), message(msg) { }
 
     TestPartResult::Type const type;
     const char* const file;
     int const line;
     std::string const message;
 
    private:
     GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
   };
 
   AssertHelperData* const data_;
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
 };
 
 enum GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW };
 
 GTEST_API_ GTEST_ATTRIBUTE_PRINTF_(2, 3) void ColoredPrintf(GTestColor color,
                                                             const char* fmt,
                                                             ...);
 
 }  // namespace internal
 
 // The pure interface class that all value-parameterized tests inherit from.
 // A value-parameterized class must inherit from both ::testing::Test and
 // ::testing::WithParamInterface. In most cases that just means inheriting
 // from ::testing::TestWithParam, but more complicated test hierarchies
 // may need to inherit from Test and WithParamInterface at different levels.
 //
 // This interface has support for accessing the test parameter value via
 // the GetParam() method.
 //
 // Use it with one of the parameter generator defining functions, like Range(),
 // Values(), ValuesIn(), Bool(), and Combine().
 //
 // class FooTest : public ::testing::TestWithParam<int> {
 //  protected:
 //   FooTest() {
 //     // Can use GetParam() here.
 //   }
 //   virtual ~FooTest() {
 //     // Can use GetParam() here.
 //   }
 //   virtual void SetUp() {
 //     // Can use GetParam() here.
 //   }
 //   virtual void TearDown {
 //     // Can use GetParam() here.
 //   }
 // };
 // TEST_P(FooTest, DoesBar) {
 //   // Can use GetParam() method here.
 //   Foo foo;
 //   ASSERT_TRUE(foo.DoesBar(GetParam()));
 // }
 // INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
 
 template <typename T>
 class WithParamInterface {
  public:
   typedef T ParamType;
   virtual ~WithParamInterface() {}
 
   // The current parameter value. Is also available in the test fixture's
   // constructor.
   static const ParamType& GetParam() {
     GTEST_CHECK_(parameter_ != nullptr)
         << "GetParam() can only be called inside a value-parameterized test "
         << "-- did you intend to write TEST_P instead of TEST_F?";
     return *parameter_;
   }
 
  private:
   // Sets parameter value. The caller is responsible for making sure the value
   // remains alive and unchanged throughout the current test.
   static void SetParam(const ParamType* parameter) {
     parameter_ = parameter;
   }
 
   // Static value used for accessing parameter during a test lifetime.
   static const ParamType* parameter_;
 
   // TestClass must be a subclass of WithParamInterface<T> and Test.
   template <class TestClass> friend class internal::ParameterizedTestFactory;
 };
 
 template <typename T>
 const T* WithParamInterface<T>::parameter_ = nullptr;
 
 // Most value-parameterized classes can ignore the existence of
 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
 
 template <typename T>
 class TestWithParam : public Test, public WithParamInterface<T> {
 };
 
 // Macros for indicating success/failure in test code.
 
 // Skips test in runtime.
 // Skipping test aborts current function.
 // Skipped tests are neither successful nor failed.
 #define GTEST_SKIP() GTEST_SKIP_("Skipped")
 
 // ADD_FAILURE unconditionally adds a failure to the current test.
 // SUCCEED generates a success - it doesn't automatically make the
 // current test successful, as a test is only successful when it has
 // no failure.
 //
 // EXPECT_* verifies that a certain condition is satisfied.  If not,
 // it behaves like ADD_FAILURE.  In particular:
 //
 //   EXPECT_TRUE  verifies that a Boolean condition is true.
 //   EXPECT_FALSE verifies that a Boolean condition is false.
 //
 // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
 // that they will also abort the current function on failure.  People
 // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
 // writing data-driven tests often find themselves using ADD_FAILURE
 // and EXPECT_* more.
 
 // Generates a nonfatal failure with a generic message.
 #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
 
 // Generates a nonfatal failure at the given source file location with
 // a generic message.
 #define ADD_FAILURE_AT(file, line) \
   GTEST_MESSAGE_AT_(file, line, "Failed", \
                     ::testing::TestPartResult::kNonFatalFailure)
 
 // Generates a fatal failure with a generic message.
 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
 
 // Define this macro to 1 to omit the definition of FAIL(), which is a
 // generic name and clashes with some other libraries.
 #if !GTEST_DONT_DEFINE_FAIL
 # define FAIL() GTEST_FAIL()
 #endif
 
 // Generates a success with a generic message.
 #define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
 
 // Define this macro to 1 to omit the definition of SUCCEED(), which
 // is a generic name and clashes with some other libraries.
 #if !GTEST_DONT_DEFINE_SUCCEED
 # define SUCCEED() GTEST_SUCCEED()
 #endif
 
 // Macros for testing exceptions.
 //
 //    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
 //         Tests that the statement throws the expected exception.
 //    * {ASSERT|EXPECT}_NO_THROW(statement):
 //         Tests that the statement doesn't throw any exception.
 //    * {ASSERT|EXPECT}_ANY_THROW(statement):
 //         Tests that the statement throws an exception.
 
 #define EXPECT_THROW(statement, expected_exception) \
   GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
 #define EXPECT_NO_THROW(statement) \
   GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
 #define EXPECT_ANY_THROW(statement) \
   GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
 #define ASSERT_THROW(statement, expected_exception) \
   GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
 #define ASSERT_NO_THROW(statement) \
   GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
 #define ASSERT_ANY_THROW(statement) \
   GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
 
 // Boolean assertions. Condition can be either a Boolean expression or an
 // AssertionResult. For more information on how to use AssertionResult with
 // these macros see comments on that class.
 #define EXPECT_TRUE(condition) \
   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                       GTEST_NONFATAL_FAILURE_)
 #define EXPECT_FALSE(condition) \
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_NONFATAL_FAILURE_)
 #define ASSERT_TRUE(condition) \
   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                       GTEST_FATAL_FAILURE_)
 #define ASSERT_FALSE(condition) \
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_FATAL_FAILURE_)
 
 // Macros for testing equalities and inequalities.
 //
 //    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
 //    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
 //    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
 //    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
 //    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
 //    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
 //
 // When they are not, Google Test prints both the tested expressions and
 // their actual values.  The values must be compatible built-in types,
 // or you will get a compiler error.  By "compatible" we mean that the
 // values can be compared by the respective operator.
 //
 // Note:
 //
 //   1. It is possible to make a user-defined type work with
 //   {ASSERT|EXPECT}_??(), but that requires overloading the
 //   comparison operators and is thus discouraged by the Google C++
 //   Usage Guide.  Therefore, you are advised to use the
 //   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
 //   equal.
 //
 //   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
 //   pointers (in particular, C strings).  Therefore, if you use it
 //   with two C strings, you are testing how their locations in memory
 //   are related, not how their content is related.  To compare two C
 //   strings by content, use {ASSERT|EXPECT}_STR*().
 //
 //   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
 //   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
 //   what the actual value is when it fails, and similarly for the
 //   other comparisons.
 //
 //   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
 //   evaluate their arguments, which is undefined.
 //
 //   5. These macros evaluate their arguments exactly once.
 //
 // Examples:
 //
 //   EXPECT_NE(Foo(), 5);
 //   EXPECT_EQ(a_pointer, NULL);
 //   ASSERT_LT(i, array_size);
 //   ASSERT_GT(records.size(), 0) << "There is no record left.";
 
 #define EXPECT_EQ(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal:: \
                       EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
                       val1, val2)
 #define EXPECT_NE(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
 #define EXPECT_LE(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
 #define EXPECT_LT(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
 #define EXPECT_GE(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
 #define EXPECT_GT(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
 
 #define GTEST_ASSERT_EQ(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal:: \
                       EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
                       val1, val2)
 #define GTEST_ASSERT_NE(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
 #define GTEST_ASSERT_LE(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
 #define GTEST_ASSERT_LT(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
 #define GTEST_ASSERT_GE(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
 #define GTEST_ASSERT_GT(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
 
 // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
 // ASSERT_XY(), which clashes with some users' own code.
 
 #if !GTEST_DONT_DEFINE_ASSERT_EQ
 # define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_NE
 # define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_LE
 # define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_LT
 # define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_GE
 # define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
 #endif
 
 #if !GTEST_DONT_DEFINE_ASSERT_GT
 # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
 #endif
 
 // C-string Comparisons.  All tests treat NULL and any non-NULL string
 // as different.  Two NULLs are equal.
 //
 //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
 //    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
 //    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
 //    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
 //
 // For wide or narrow string objects, you can use the
 // {ASSERT|EXPECT}_??() macros.
 //
 // Don't depend on the order in which the arguments are evaluated,
 // which is undefined.
 //
 // These macros evaluate their arguments exactly once.
 
 #define EXPECT_STREQ(s1, s2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
 #define EXPECT_STRNE(s1, s2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
 #define EXPECT_STRCASEEQ(s1, s2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
 #define EXPECT_STRCASENE(s1, s2)\
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
 
 #define ASSERT_STREQ(s1, s2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
 #define ASSERT_STRNE(s1, s2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
 #define ASSERT_STRCASEEQ(s1, s2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
 #define ASSERT_STRCASENE(s1, s2)\
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
 
 // Macros for comparing floating-point numbers.
 //
 //    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
 //         Tests that two float values are almost equal.
 //    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
 //         Tests that two double values are almost equal.
 //    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
 //         Tests that v1 and v2 are within the given distance to each other.
 //
 // Google Test uses ULP-based comparison to automatically pick a default
 // error bound that is appropriate for the operands.  See the
 // FloatingPoint template class in gtest-internal.h if you are
 // interested in the implementation details.
 
 #define EXPECT_FLOAT_EQ(val1, val2)\
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                       val1, val2)
 
 #define EXPECT_DOUBLE_EQ(val1, val2)\
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                       val1, val2)
 
 #define ASSERT_FLOAT_EQ(val1, val2)\
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                       val1, val2)
 
 #define ASSERT_DOUBLE_EQ(val1, val2)\
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                       val1, val2)
 
 #define EXPECT_NEAR(val1, val2, abs_error)\
   EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                       val1, val2, abs_error)
 
 #define ASSERT_NEAR(val1, val2, abs_error)\
   ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                       val1, val2, abs_error)
 
 // These predicate format functions work on floating-point values, and
 // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
 //
 //   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
 
 // Asserts that val1 is less than, or almost equal to, val2.  Fails
 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
 GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
                                    float val1, float val2);
 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
                                     double val1, double val2);
 
 
 #if GTEST_OS_WINDOWS
 
 // Macros that test for HRESULT failure and success, these are only useful
 // on Windows, and rely on Windows SDK macros and APIs to compile.
 //
 //    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
 //
 // When expr unexpectedly fails or succeeds, Google Test prints the
 // expected result and the actual result with both a human-readable
 // string representation of the error, if available, as well as the
 // hex result code.
 # define EXPECT_HRESULT_SUCCEEDED(expr) \
     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
 
 # define ASSERT_HRESULT_SUCCEEDED(expr) \
     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
 
 # define EXPECT_HRESULT_FAILED(expr) \
     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
 
 # define ASSERT_HRESULT_FAILED(expr) \
     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
 
 #endif  // GTEST_OS_WINDOWS
 
 // Macros that execute statement and check that it doesn't generate new fatal
 // failures in the current thread.
 //
 //   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
 //
 // Examples:
 //
 //   EXPECT_NO_FATAL_FAILURE(Process());
 //   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
 //
 #define ASSERT_NO_FATAL_FAILURE(statement) \
     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
 #define EXPECT_NO_FATAL_FAILURE(statement) \
     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
 
 // Causes a trace (including the given source file path and line number,
 // and the given message) to be included in every test failure message generated
 // by code in the scope of the lifetime of an instance of this class. The effect
 // is undone with the destruction of the instance.
 //
 // The message argument can be anything streamable to std::ostream.
 //
 // Example:
 //   testing::ScopedTrace trace("file.cc", 123, "message");
 //
 class GTEST_API_ ScopedTrace {
  public:
   // The c'tor pushes the given source file location and message onto
   // a trace stack maintained by Google Test.
 
   // Template version. Uses Message() to convert the values into strings.
   // Slow, but flexible.
   template <typename T>
   ScopedTrace(const char* file, int line, const T& message) {
     PushTrace(file, line, (Message() << message).GetString());
   }
 
   // Optimize for some known types.
   ScopedTrace(const char* file, int line, const char* message) {
     PushTrace(file, line, message ? message : "(null)");
   }
 
 #if GTEST_HAS_GLOBAL_STRING
   ScopedTrace(const char* file, int line, const ::string& message) {
     PushTrace(file, line, message);
   }
 #endif
 
   ScopedTrace(const char* file, int line, const std::string& message) {
     PushTrace(file, line, message);
   }
 
   // The d'tor pops the info pushed by the c'tor.
   //
   // Note that the d'tor is not virtual in order to be efficient.
   // Don't inherit from ScopedTrace!
   ~ScopedTrace();
 
  private:
   void PushTrace(const char* file, int line, std::string message);
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
 } GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
                             // c'tor and d'tor.  Therefore it doesn't
                             // need to be used otherwise.
 
 // Causes a trace (including the source file path, the current line
 // number, and the given message) to be included in every test failure
 // message generated by code in the current scope.  The effect is
 // undone when the control leaves the current scope.
 //
 // The message argument can be anything streamable to std::ostream.
 //
 // In the implementation, we include the current line number as part
 // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
 // to appear in the same block - as long as they are on different
 // lines.
 //
 // Assuming that each thread maintains its own stack of traces.
 // Therefore, a SCOPED_TRACE() would (correctly) only affect the
 // assertions in its own thread.
 #define SCOPED_TRACE(message) \
   ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
     __FILE__, __LINE__, (message))
 
 
 // Compile-time assertion for type equality.
 // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
 // the same type.  The value it returns is not interesting.
 //
 // Instead of making StaticAssertTypeEq a class template, we make it a
 // function template that invokes a helper class template.  This
 // prevents a user from misusing StaticAssertTypeEq<T1, T2> by
 // defining objects of that type.
 //
 // CAVEAT:
 //
 // When used inside a method of a class template,
 // StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
 // instantiated.  For example, given:
 //
 //   template <typename T> class Foo {
 //    public:
 //     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
 //   };
 //
 // the code:
 //
 //   void Test1() { Foo<bool> foo; }
 //
 // will NOT generate a compiler error, as Foo<bool>::Bar() is never
 // actually instantiated.  Instead, you need:
 //
 //   void Test2() { Foo<bool> foo; foo.Bar(); }
 //
 // to cause a compiler error.
 template <typename T1, typename T2>
 bool StaticAssertTypeEq() {
   (void)internal::StaticAssertTypeEqHelper<T1, T2>();
   return true;
 }
 
 // Defines a test.
 //
 // The first parameter is the name of the test suite, and the second
 // parameter is the name of the test within the test suite.
 //
 // The convention is to end the test suite name with "Test".  For
 // example, a test suite for the Foo class can be named FooTest.
 //
 // Test code should appear between braces after an invocation of
 // this macro.  Example:
 //
 //   TEST(FooTest, InitializesCorrectly) {
 //     Foo foo;
 //     EXPECT_TRUE(foo.StatusIsOK());
 //   }
 
 // Note that we call GetTestTypeId() instead of GetTypeId<
 // ::testing::Test>() here to get the type ID of testing::Test.  This
 // is to work around a suspected linker bug when using Google Test as
 // a framework on Mac OS X.  The bug causes GetTypeId<
 // ::testing::Test>() to return different values depending on whether
 // the call is from the Google Test framework itself or from user test
 // code.  GetTestTypeId() is guaranteed to always return the same
 // value, as it always calls GetTypeId<>() from the Google Test
 // framework.
 #define GTEST_TEST(test_suite_name, test_name)             \
   GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
               ::testing::internal::GetTestTypeId())
 
 // Define this macro to 1 to omit the definition of TEST(), which
 // is a generic name and clashes with some other libraries.
 #if !GTEST_DONT_DEFINE_TEST
 #define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
 #endif
 
 // Defines a test that uses a test fixture.
 //
 // The first parameter is the name of the test fixture class, which
 // also doubles as the test suite name.  The second parameter is the
 // name of the test within the test suite.
 //
 // A test fixture class must be declared earlier.  The user should put
 // the test code between braces after using this macro.  Example:
 //
 //   class FooTest : public testing::Test {
 //    protected:
 //     virtual void SetUp() { b_.AddElement(3); }
 //
 //     Foo a_;
 //     Foo b_;
 //   };
 //
 //   TEST_F(FooTest, InitializesCorrectly) {
 //     EXPECT_TRUE(a_.StatusIsOK());
 //   }
 //
 //   TEST_F(FooTest, ReturnsElementCountCorrectly) {
 //     EXPECT_EQ(a_.size(), 0);
 //     EXPECT_EQ(b_.size(), 1);
 //   }
 
 #define TEST_F(test_fixture, test_name)\
   GTEST_TEST_(test_fixture, test_name, test_fixture, \
               ::testing::internal::GetTypeId<test_fixture>())
 
 // Returns a path to temporary directory.
 // Tries to determine an appropriate directory for the platform.
 GTEST_API_ std::string TempDir();
 
 #ifdef _MSC_VER
 #  pragma warning(pop)
 #endif
 
 // Dynamically registers a test with the framework.
 //
 // This is an advanced API only to be used when the `TEST` macros are
 // insufficient. The macros should be preferred when possible, as they avoid
 // most of the complexity of calling this function.
 //
 // The `factory` argument is a factory callable (move-constructible) object or
 // function pointer that creates a new instance of the Test object. It
 // handles ownership to the caller. The signature of the callable is
 // `Fixture*()`, where `Fixture` is the test fixture class for the test. All
 // tests registered with the same `test_suite_name` must return the same
 // fixture type. This is checked at runtime.
 //
 // The framework will infer the fixture class from the factory and will call
 // the `SetUpTestSuite` and `TearDownTestSuite` for it.
 //
 // Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
 // undefined.
 //
 // Use case example:
 //
 // class MyFixture : public ::testing::Test {
 //  public:
 //   // All of these optional, just like in regular macro usage.
 //   static void SetUpTestSuite() { ... }
 //   static void TearDownTestSuite() { ... }
 //   void SetUp() override { ... }
 //   void TearDown() override { ... }
 // };
 //
 // class MyTest : public MyFixture {
 //  public:
 //   explicit MyTest(int data) : data_(data) {}
 //   void TestBody() override { ... }
 //
 //  private:
 //   int data_;
 // };
 //
 // void RegisterMyTests(const std::vector<int>& values) {
 //   for (int v : values) {
 //     ::testing::RegisterTest(
 //         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
 //         std::to_string(v).c_str(),
 //         __FILE__, __LINE__,
 //         // Important to use the fixture type as the return type here.
 //         [=]() -> MyFixture* { return new MyTest(v); });
 //   }
 // }
 // ...
 // int main(int argc, char** argv) {
 //   std::vector<int> values_to_test = LoadValuesFromConfig();
 //   RegisterMyTests(values_to_test);
 //   ...
 //   return RUN_ALL_TESTS();
 // }
 //
 template <int&... ExplicitParameterBarrier, typename Factory>
 TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
                        const char* type_param, const char* value_param,
                        const char* file, int line, Factory factory) {
   using TestT = typename std::remove_pointer<decltype(factory())>::type;
 
   class FactoryImpl : public internal::TestFactoryBase {
    public:
     explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
     Test* CreateTest() override { return factory_(); }
 
    private:
     Factory factory_;
   };
 
   return internal::MakeAndRegisterTestInfo(
       test_suite_name, test_name, type_param, value_param,
       internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
       internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(),
       internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(),
       new FactoryImpl{std::move(factory)});
 }
 
 }  // namespace testing
 
 // Use this function in main() to run all tests.  It returns 0 if all
 // tests are successful, or 1 otherwise.
 //
 // RUN_ALL_TESTS() should be invoked after the command line has been
 // parsed by InitGoogleTest().
 //
 // This function was formerly a macro; thus, it is in the global
 // namespace and has an all-caps name.
 int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
 
 inline int RUN_ALL_TESTS() {
   return ::testing::UnitTest::GetInstance()->Run();
 }
 
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 
 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_
diff --git a/googletest/make/Makefile b/googletest/make/Makefile
index 91eb68b5..b62da67a 100644
--- a/googletest/make/Makefile
+++ b/googletest/make/Makefile
@@ -1,82 +1,88 @@
 # A sample Makefile for building Google Test and using it in user
 # tests.  Please tweak it to suit your environment and project.  You
 # may want to move it to your project's root directory.
 #
 # SYNOPSIS:
 #
 #   make [all]  - makes everything.
 #   make TARGET - makes the given target.
 #   make clean  - removes all files generated by make.
 
 # Please tweak the following variable definitions as needed by your
 # project, except GTEST_HEADERS, which you can use in your own targets
 # but shouldn't modify.
 
 # Points to the root of Google Test, relative to where this file is.
 # Remember to tweak this if you move this file.
 GTEST_DIR = ..
 
+# Points to the location of the Google Test libraries
+GTEST_LIB_DIR = .
+
 # Where to find user code.
 USER_DIR = ../samples
 
 # Flags passed to the preprocessor.
 # Set Google Test's header directory as a system directory, such that
 # the compiler doesn't generate warnings in Google Test headers.
 CPPFLAGS += -isystem $(GTEST_DIR)/include
 
 # Flags passed to the C++ compiler.
 CXXFLAGS += -g -Wall -Wextra -pthread -std=c++11
 
+# Google Test libraries
+GTEST_LIBS = libgtest.a libgtest_main.a
+
 # All tests produced by this Makefile.  Remember to add new tests you
 # created to the list.
 TESTS = sample1_unittest
 
 # All Google Test headers.  Usually you shouldn't change this
 # definition.
 GTEST_HEADERS = $(GTEST_DIR)/include/gtest/*.h \
                 $(GTEST_DIR)/include/gtest/internal/*.h
 
 # House-keeping build targets.
 
-all : $(TESTS)
+all : $(GTEST_LIBS) $(TESTS)
 
 clean :
-	rm -f $(TESTS) gtest.a gtest_main.a *.o
+	rm -f $(GTEST_LIBS) $(TESTS) *.o
 
 # Builds gtest.a and gtest_main.a.
 
 # Usually you shouldn't tweak such internal variables, indicated by a
 # trailing _.
 GTEST_SRCS_ = $(GTEST_DIR)/src/*.cc $(GTEST_DIR)/src/*.h $(GTEST_HEADERS)
 
 # For simplicity and to avoid depending on Google Test's
 # implementation details, the dependencies specified below are
 # conservative and not optimized.  This is fine as Google Test
 # compiles fast and for ordinary users its source rarely changes.
 gtest-all.o : $(GTEST_SRCS_)
 	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
             $(GTEST_DIR)/src/gtest-all.cc
 
 gtest_main.o : $(GTEST_SRCS_)
 	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
             $(GTEST_DIR)/src/gtest_main.cc
 
-gtest.a : gtest-all.o
+libgtest.a : gtest-all.o
 	$(AR) $(ARFLAGS) $@ $^
 
-gtest_main.a : gtest-all.o gtest_main.o
+libgtest_main.a : gtest-all.o gtest_main.o
 	$(AR) $(ARFLAGS) $@ $^
 
 # Builds a sample test.  A test should link with either gtest.a or
 # gtest_main.a, depending on whether it defines its own main()
 # function.
 
 sample1.o : $(USER_DIR)/sample1.cc $(USER_DIR)/sample1.h $(GTEST_HEADERS)
 	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1.cc
 
 sample1_unittest.o : $(USER_DIR)/sample1_unittest.cc \
                      $(USER_DIR)/sample1.h $(GTEST_HEADERS)
 	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(USER_DIR)/sample1_unittest.cc
 
-sample1_unittest : sample1.o sample1_unittest.o gtest_main.a
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
+sample1_unittest : sample1.o sample1_unittest.o $(GTEST_LIBS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -L$(GTEST_LIB_DIR) -lgtest_main -lpthread $^ -o $@
diff --git a/googletest/xcode/gtest.xcodeproj/project.pbxproj b/googletest/xcode/gtest.xcodeproj/project.pbxproj
index afc4d3d0..003bff8c 100644
--- a/googletest/xcode/gtest.xcodeproj/project.pbxproj
+++ b/googletest/xcode/gtest.xcodeproj/project.pbxproj
@@ -1,1170 +1,1182 @@
 // !$*UTF8*$!
 {
 	archiveVersion = 1;
 	classes = {
 	};
 	objectVersion = 46;
 	objects = {
 
 /* Begin PBXAggregateTarget section */
 		3B238F5F0E828B5400846E11 /* Check */ = {
 			isa = PBXAggregateTarget;
 			buildConfigurationList = 3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */;
 			buildPhases = (
 				3B238F5E0E828B5400846E11 /* ShellScript */,
 			);
 			dependencies = (
 				40899F9D0FFA740F000B29AE /* PBXTargetDependency */,
 				40C849F7101A43440083642A /* PBXTargetDependency */,
 				4089A0980FFAD34A000B29AE /* PBXTargetDependency */,
 				40C849F9101A43490083642A /* PBXTargetDependency */,
 			);
 			name = Check;
 			productName = Check;
 		};
 		40C44ADC0E3798F4008FCC51 /* Version Info */ = {
 			isa = PBXAggregateTarget;
 			buildConfigurationList = 40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */;
 			buildPhases = (
 				40C44ADB0E3798F4008FCC51 /* Generate Version.h */,
 			);
 			comments = "The generation of Version.h must be performed in its own target. Since the Info.plist is preprocessed before any of the other build phases in gtest, the Version.h file would not be ready if included as a build phase of that target.";
 			dependencies = (
 			);
 			name = "Version Info";
 			productName = Version.h;
 		};
 /* End PBXAggregateTarget section */
 
 /* Begin PBXBuildFile section */
 		224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */ = {isa = PBXBuildFile; fileRef = 224A12A20E9EADCC00BD17FD /* gtest-test-part.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */; };
 		3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DB0E2F799B00CF7658 /* gtest-death-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		404884390E2F799B00CF7658 /* gtest-message.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DC0E2F799B00CF7658 /* gtest-message.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DD0E2F799B00CF7658 /* gtest-spi.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		4048843B0E2F799B00CF7658 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DE0E2F799B00CF7658 /* gtest.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */ = {isa = PBXBuildFile; fileRef = 404883E00E2F799B00CF7658 /* gtest_prod.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		404884500E2F799B00CF7658 /* README.md in Resources */ = {isa = PBXBuildFile; fileRef = 404883F60E2F799B00CF7658 /* README.md */; };
 		404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */; };
 		404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E30E2F799B00CF7658 /* gtest-filepath.h */; };
 		404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E40E2F799B00CF7658 /* gtest-internal.h */; };
 		404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E50E2F799B00CF7658 /* gtest-port.h */; };
 		404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 404883E60E2F799B00CF7658 /* gtest-string.h */; };
+		404884AC0E2F7CD900CF7658 /* CHANGES in Resources */ = {isa = PBXBuildFile; fileRef = 404884A90E2F7CD900CF7658 /* CHANGES */; };
 		404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */ = {isa = PBXBuildFile; fileRef = 404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */; };
 		404884AE0E2F7CD900CF7658 /* LICENSE in Resources */ = {isa = PBXBuildFile; fileRef = 404884AB0E2F7CD900CF7658 /* LICENSE */; };
 		40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
+		40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 40899F4D0FFA7271000B29AE /* gtest-tuple.h */; };
 		40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
 		4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
 		4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
 		40C848FF101A21150083642A /* gtest-all.cc in Sources */ = {isa = PBXBuildFile; fileRef = 224A12A10E9EADA700BD17FD /* gtest-all.cc */; };
 		40C84915101A21DF0083642A /* gtest_main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4048840D0E2F799B00CF7658 /* gtest_main.cc */; };
 		40C84916101A235B0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
 		40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
 		40C84978101A36540083642A /* libgtest_main.a in Resources */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
 		40C84980101A36850083642A /* gtest_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 3B238C120E7FE13C00846E11 /* gtest_unittest.cc */; };
 		40C84982101A36850083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
 		40C84983101A36850083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
 		40C8498F101A36A60083642A /* sample1.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02C0FFACF7F000B29AE /* sample1.cc */; };
 		40C84990101A36A60083642A /* sample1_unittest.cc in Sources */ = {isa = PBXBuildFile; fileRef = 4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */; };
 		40C84992101A36A60083642A /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C848FA101A209C0083642A /* libgtest.a */; };
 		40C84993101A36A60083642A /* libgtest_main.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 40C8490B101A217E0083642A /* libgtest_main.a */; };
 		40C849A2101A37050083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
 		40C849A4101A37150083642A /* gtest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4539C8FF0EC27F6400A70F4C /* gtest.framework */; };
 		4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */ = {isa = PBXBuildFile; fileRef = 4539C9330EC280AE00A70F4C /* gtest-param-test.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */; };
 		4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */; };
 		4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = 4539C9370EC280E200A70F4C /* gtest-param-util.h */; };
 		4567C8181264FF71007740BE /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = 4567C8171264FF71007740BE /* gtest-printers.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		F67D4F3E1C7F5D8B0017C729 /* gtest-port-arch.h in Headers */ = {isa = PBXBuildFile; fileRef = F67D4F3D1C7F5D8B0017C729 /* gtest-port-arch.h */; };
 		F67D4F3F1C7F5DA70017C729 /* gtest-port-arch.h in Copy Headers Internal */ = {isa = PBXBuildFile; fileRef = F67D4F3D1C7F5D8B0017C729 /* gtest-port-arch.h */; };
 		F67D4F441C7F5DD00017C729 /* gtest-port.h in Headers */ = {isa = PBXBuildFile; fileRef = F67D4F411C7F5DD00017C729 /* gtest-port.h */; };
 		F67D4F451C7F5DD00017C729 /* gtest-printers.h in Headers */ = {isa = PBXBuildFile; fileRef = F67D4F421C7F5DD00017C729 /* gtest-printers.h */; };
 		F67D4F461C7F5DD00017C729 /* gtest.h in Headers */ = {isa = PBXBuildFile; fileRef = F67D4F431C7F5DD00017C729 /* gtest.h */; };
 		F67D4F481C7F5E160017C729 /* gtest-port.h in Copy Headers Internal Custom */ = {isa = PBXBuildFile; fileRef = F67D4F411C7F5DD00017C729 /* gtest-port.h */; };
 		F67D4F491C7F5E260017C729 /* gtest-printers.h in Copy Headers Internal Custom */ = {isa = PBXBuildFile; fileRef = F67D4F421C7F5DD00017C729 /* gtest-printers.h */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
 		40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40899F420FFA7184000B29AE;
 			remoteInfo = gtest_unittest;
 		};
 		4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 4089A0120FFACEFC000B29AE;
 			remoteInfo = sample1_unittest;
 		};
 		408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C848F9101A209C0083642A;
 			remoteInfo = "gtest-static";
 		};
 		40C44AE50E379922008FCC51 /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C44ADC0E3798F4008FCC51;
 			remoteInfo = Version.h;
 		};
 		40C8497C101A36850083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C848F9101A209C0083642A;
 			remoteInfo = "gtest-static";
 		};
 		40C8497E101A36850083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C8490A101A217E0083642A;
 			remoteInfo = "gtest_main-static";
 		};
 		40C8498B101A36A60083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C848F9101A209C0083642A;
 			remoteInfo = "gtest-static";
 		};
 		40C8498D101A36A60083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C8490A101A217E0083642A;
 			remoteInfo = "gtest_main-static";
 		};
 		40C8499B101A36DC0083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C8490A101A217E0083642A;
 			remoteInfo = "gtest_main-static";
 		};
 		40C8499D101A36E50083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
 			remoteInfo = "gtest-framework";
 		};
 		40C8499F101A36F10083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 8D07F2BC0486CC7A007CD1D0;
 			remoteInfo = "gtest-framework";
 		};
 		40C849F6101A43440083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C8497A101A36850083642A;
 			remoteInfo = "gtest_unittest-static";
 		};
 		40C849F8101A43490083642A /* PBXContainerItemProxy */ = {
 			isa = PBXContainerItemProxy;
 			containerPortal = 0867D690FE84028FC02AAC07 /* Project object */;
 			proxyType = 1;
 			remoteGlobalIDString = 40C84989101A36A60083642A;
 			remoteInfo = "sample1_unittest-static";
 		};
 /* End PBXContainerItemProxy section */
 
 /* Begin PBXCopyFilesBuildPhase section */
 		404884A50E2F7C0400CF7658 /* Copy Headers Internal */ = {
 			isa = PBXCopyFilesBuildPhase;
 			buildActionMask = 2147483647;
 			dstPath = Headers/internal;
 			dstSubfolderSpec = 6;
 			files = (
 				F67D4F3F1C7F5DA70017C729 /* gtest-port-arch.h in Copy Headers Internal */,
 				404884A00E2F7BE600CF7658 /* gtest-death-test-internal.h in Copy Headers Internal */,
 				404884A10E2F7BE600CF7658 /* gtest-filepath.h in Copy Headers Internal */,
 				404884A20E2F7BE600CF7658 /* gtest-internal.h in Copy Headers Internal */,
+				4539C9380EC280E200A70F4C /* gtest-linked_ptr.h in Copy Headers Internal */,
 				4539C9390EC280E200A70F4C /* gtest-param-util-generated.h in Copy Headers Internal */,
 				4539C93A0EC280E200A70F4C /* gtest-param-util.h in Copy Headers Internal */,
 				404884A30E2F7BE600CF7658 /* gtest-port.h in Copy Headers Internal */,
 				404884A40E2F7BE600CF7658 /* gtest-string.h in Copy Headers Internal */,
+				40899F500FFA7281000B29AE /* gtest-tuple.h in Copy Headers Internal */,
 				3BF6F2A00E79B5AD000F2EEE /* gtest-type-util.h in Copy Headers Internal */,
 			);
 			name = "Copy Headers Internal";
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		F67D4F471C7F5DF60017C729 /* Copy Headers Internal Custom */ = {
 			isa = PBXCopyFilesBuildPhase;
 			buildActionMask = 2147483647;
 			dstPath = Headers/internal/custom;
 			dstSubfolderSpec = 6;
 			files = (
 				F67D4F491C7F5E260017C729 /* gtest-printers.h in Copy Headers Internal Custom */,
 				F67D4F481C7F5E160017C729 /* gtest-port.h in Copy Headers Internal Custom */,
 			);
 			name = "Copy Headers Internal Custom";
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
 		224A12A10E9EADA700BD17FD /* gtest-all.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = "gtest-all.cc"; sourceTree = "<group>"; };
 		224A12A20E9EADCC00BD17FD /* gtest-test-part.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = "gtest-test-part.h"; sourceTree = "<group>"; };
 		3B238C120E7FE13C00846E11 /* gtest_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_unittest.cc; sourceTree = "<group>"; };
 		3B87D2100E96B92E000D1852 /* runtests.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = runtests.sh; sourceTree = "<group>"; };
 		3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-type-util.h"; sourceTree = "<group>"; };
 		3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-typed-test.h"; sourceTree = "<group>"; };
 		403EE37C0E377822004BD1E2 /* versiongenerate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = versiongenerate.py; sourceTree = "<group>"; };
 		404883DB0E2F799B00CF7658 /* gtest-death-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test.h"; sourceTree = "<group>"; };
 		404883DC0E2F799B00CF7658 /* gtest-message.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-message.h"; sourceTree = "<group>"; };
 		404883DD0E2F799B00CF7658 /* gtest-spi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-spi.h"; sourceTree = "<group>"; };
 		404883DE0E2F799B00CF7658 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };
 		404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_pred_impl.h; sourceTree = "<group>"; };
 		404883E00E2F799B00CF7658 /* gtest_prod.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest_prod.h; sourceTree = "<group>"; };
 		404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-death-test-internal.h"; sourceTree = "<group>"; };
 		404883E30E2F799B00CF7658 /* gtest-filepath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-filepath.h"; sourceTree = "<group>"; };
 		404883E40E2F799B00CF7658 /* gtest-internal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-internal.h"; sourceTree = "<group>"; };
 		404883E50E2F799B00CF7658 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };
 		404883E60E2F799B00CF7658 /* gtest-string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-string.h"; sourceTree = "<group>"; };
 		404883F60E2F799B00CF7658 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = README.md; path = ../README.md; sourceTree = SOURCE_ROOT; };
 		4048840D0E2F799B00CF7658 /* gtest_main.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gtest_main.cc; sourceTree = "<group>"; };
+		404884A90E2F7CD900CF7658 /* CHANGES */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CHANGES; path = ../CHANGES; sourceTree = SOURCE_ROOT; };
 		404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CONTRIBUTORS; path = ../CONTRIBUTORS; sourceTree = SOURCE_ROOT; };
 		404884AB0E2F7CD900CF7658 /* LICENSE */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = LICENSE; path = ../LICENSE; sourceTree = SOURCE_ROOT; };
 		40899F430FFA7184000B29AE /* gtest_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "gtest_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
+		40899F4D0FFA7271000B29AE /* gtest-tuple.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-tuple.h"; sourceTree = "<group>"; };
 		40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = StaticLibraryTarget.xcconfig; sourceTree = "<group>"; };
 		4089A0130FFACEFC000B29AE /* sample1_unittest-framework */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-framework"; sourceTree = BUILT_PRODUCTS_DIR; };
 		4089A02C0FFACF7F000B29AE /* sample1.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1.cc; sourceTree = "<group>"; };
 		4089A02D0FFACF7F000B29AE /* sample1.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sample1.h; sourceTree = "<group>"; };
 		4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sample1_unittest.cc; sourceTree = "<group>"; };
 		40C848FA101A209C0083642A /* libgtest.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		40C8490B101A217E0083642A /* libgtest_main.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgtest_main.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		40C84987101A36850083642A /* gtest_unittest */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = gtest_unittest; sourceTree = BUILT_PRODUCTS_DIR; };
 		40C84997101A36A60083642A /* sample1_unittest-static */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "sample1_unittest-static"; sourceTree = BUILT_PRODUCTS_DIR; };
 		40D4CDF10E30E07400294801 /* DebugProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugProject.xcconfig; sourceTree = "<group>"; };
 		40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = FrameworkTarget.xcconfig; sourceTree = "<group>"; };
 		40D4CDF30E30E07400294801 /* General.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = General.xcconfig; sourceTree = "<group>"; };
 		40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ReleaseProject.xcconfig; sourceTree = "<group>"; };
 		40D4CF510E30F5E200294801 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		4539C8FF0EC27F6400A70F4C /* gtest.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = gtest.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		4539C9330EC280AE00A70F4C /* gtest-param-test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-test.h"; sourceTree = "<group>"; };
+		4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-linked_ptr.h"; sourceTree = "<group>"; };
 		4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util-generated.h"; sourceTree = "<group>"; };
 		4539C9370EC280E200A70F4C /* gtest-param-util.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-param-util.h"; sourceTree = "<group>"; };
 		4567C8171264FF71007740BE /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };
 		F67D4F3D1C7F5D8B0017C729 /* gtest-port-arch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port-arch.h"; sourceTree = "<group>"; };
 		F67D4F411C7F5DD00017C729 /* gtest-port.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-port.h"; sourceTree = "<group>"; };
 		F67D4F421C7F5DD00017C729 /* gtest-printers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "gtest-printers.h"; sourceTree = "<group>"; };
 		F67D4F431C7F5DD00017C729 /* gtest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gtest.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
 		40899F410FFA7184000B29AE /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C849A4101A37150083642A /* gtest.framework in Frameworks */,
 				40C84916101A235B0083642A /* libgtest_main.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		4089A0110FFACEFC000B29AE /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C849A2101A37050083642A /* gtest.framework in Frameworks */,
 				40C84921101A23AD0083642A /* libgtest_main.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C84981101A36850083642A /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C84982101A36850083642A /* libgtest.a in Frameworks */,
 				40C84983101A36850083642A /* libgtest_main.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C84991101A36A60083642A /* Frameworks */ = {
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C84992101A36A60083642A /* libgtest.a in Frameworks */,
 				40C84993101A36A60083642A /* libgtest_main.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
 		034768DDFF38A45A11DB9C8B /* Products */ = {
 			isa = PBXGroup;
 			children = (
 				4539C8FF0EC27F6400A70F4C /* gtest.framework */,
 				40C848FA101A209C0083642A /* libgtest.a */,
 				40C8490B101A217E0083642A /* libgtest_main.a */,
 				40899F430FFA7184000B29AE /* gtest_unittest-framework */,
 				40C84987101A36850083642A /* gtest_unittest */,
 				4089A0130FFACEFC000B29AE /* sample1_unittest-framework */,
 				40C84997101A36A60083642A /* sample1_unittest-static */,
 			);
 			name = Products;
 			sourceTree = "<group>";
 		};
 		0867D691FE84028FC02AAC07 /* gtest */ = {
 			isa = PBXGroup;
 			children = (
 				40D4CDF00E30E07400294801 /* Config */,
 				08FB77ACFE841707C02AAC07 /* Source */,
 				40D4CF4E0E30F5E200294801 /* Resources */,
 				403EE37B0E377822004BD1E2 /* Scripts */,
 				034768DDFF38A45A11DB9C8B /* Products */,
 			);
 			name = gtest;
 			sourceTree = "<group>";
 		};
 		08FB77ACFE841707C02AAC07 /* Source */ = {
 			isa = PBXGroup;
 			children = (
+				404884A90E2F7CD900CF7658 /* CHANGES */,
 				404884AA0E2F7CD900CF7658 /* CONTRIBUTORS */,
 				404884AB0E2F7CD900CF7658 /* LICENSE */,
 				404883F60E2F799B00CF7658 /* README.md */,
 				404883D90E2F799B00CF7658 /* include */,
 				4089A02F0FFACF84000B29AE /* samples */,
 				404884070E2F799B00CF7658 /* src */,
 				3B238BF00E7FE13B00846E11 /* test */,
 			);
 			name = Source;
 			sourceTree = "<group>";
 		};
 		3B238BF00E7FE13B00846E11 /* test */ = {
 			isa = PBXGroup;
 			children = (
 				3B238C120E7FE13C00846E11 /* gtest_unittest.cc */,
 			);
 			name = test;
 			path = ../test;
 			sourceTree = SOURCE_ROOT;
 		};
 		403EE37B0E377822004BD1E2 /* Scripts */ = {
 			isa = PBXGroup;
 			children = (
 				403EE37C0E377822004BD1E2 /* versiongenerate.py */,
 				3B87D2100E96B92E000D1852 /* runtests.sh */,
 			);
 			path = Scripts;
 			sourceTree = "<group>";
 		};
 		404883D90E2F799B00CF7658 /* include */ = {
 			isa = PBXGroup;
 			children = (
 				404883DA0E2F799B00CF7658 /* gtest */,
 			);
 			name = include;
 			path = ../include;
 			sourceTree = SOURCE_ROOT;
 		};
 		404883DA0E2F799B00CF7658 /* gtest */ = {
 			isa = PBXGroup;
 			children = (
 				404883E10E2F799B00CF7658 /* internal */,
 				224A12A20E9EADCC00BD17FD /* gtest-test-part.h */,
 				404883DB0E2F799B00CF7658 /* gtest-death-test.h */,
 				404883DC0E2F799B00CF7658 /* gtest-message.h */,
 				4539C9330EC280AE00A70F4C /* gtest-param-test.h */,
 				4567C8171264FF71007740BE /* gtest-printers.h */,
 				404883DD0E2F799B00CF7658 /* gtest-spi.h */,
 				404883DE0E2F799B00CF7658 /* gtest.h */,
 				404883DF0E2F799B00CF7658 /* gtest_pred_impl.h */,
 				404883E00E2F799B00CF7658 /* gtest_prod.h */,
 				3BF6F2A40E79B616000F2EEE /* gtest-typed-test.h */,
 			);
 			path = gtest;
 			sourceTree = "<group>";
 		};
 		404883E10E2F799B00CF7658 /* internal */ = {
 			isa = PBXGroup;
 			children = (
 				F67D4F401C7F5DD00017C729 /* custom */,
 				404883E20E2F799B00CF7658 /* gtest-death-test-internal.h */,
 				404883E30E2F799B00CF7658 /* gtest-filepath.h */,
 				404883E40E2F799B00CF7658 /* gtest-internal.h */,
+				4539C9350EC280E200A70F4C /* gtest-linked_ptr.h */,
 				4539C9360EC280E200A70F4C /* gtest-param-util-generated.h */,
 				4539C9370EC280E200A70F4C /* gtest-param-util.h */,
 				404883E50E2F799B00CF7658 /* gtest-port.h */,
 				F67D4F3D1C7F5D8B0017C729 /* gtest-port-arch.h */,
 				404883E60E2F799B00CF7658 /* gtest-string.h */,
+				40899F4D0FFA7271000B29AE /* gtest-tuple.h */,
 				3BF6F29F0E79B5AD000F2EEE /* gtest-type-util.h */,
 			);
 			path = internal;
 			sourceTree = "<group>";
 		};
 		404884070E2F799B00CF7658 /* src */ = {
 			isa = PBXGroup;
 			children = (
 				224A12A10E9EADA700BD17FD /* gtest-all.cc */,
 				4048840D0E2F799B00CF7658 /* gtest_main.cc */,
 			);
 			name = src;
 			path = ../src;
 			sourceTree = SOURCE_ROOT;
 		};
 		4089A02F0FFACF84000B29AE /* samples */ = {
 			isa = PBXGroup;
 			children = (
 				4089A02C0FFACF7F000B29AE /* sample1.cc */,
 				4089A02D0FFACF7F000B29AE /* sample1.h */,
 				4089A02E0FFACF7F000B29AE /* sample1_unittest.cc */,
 			);
 			name = samples;
 			path = ../samples;
 			sourceTree = SOURCE_ROOT;
 		};
 		40D4CDF00E30E07400294801 /* Config */ = {
 			isa = PBXGroup;
 			children = (
 				40D4CDF10E30E07400294801 /* DebugProject.xcconfig */,
 				40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */,
 				40D4CDF30E30E07400294801 /* General.xcconfig */,
 				40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */,
 				40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */,
 			);
 			path = Config;
 			sourceTree = "<group>";
 		};
 		40D4CF4E0E30F5E200294801 /* Resources */ = {
 			isa = PBXGroup;
 			children = (
 				40D4CF510E30F5E200294801 /* Info.plist */,
 			);
 			path = Resources;
 			sourceTree = "<group>";
 		};
 		F67D4F401C7F5DD00017C729 /* custom */ = {
 			isa = PBXGroup;
 			children = (
 				F67D4F411C7F5DD00017C729 /* gtest-port.h */,
 				F67D4F421C7F5DD00017C729 /* gtest-printers.h */,
 				F67D4F431C7F5DD00017C729 /* gtest.h */,
 			);
 			path = custom;
 			sourceTree = "<group>";
 		};
 /* End PBXGroup section */
 
 /* Begin PBXHeadersBuildPhase section */
 		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				F67D4F451C7F5DD00017C729 /* gtest-printers.h in Headers */,
 				404884380E2F799B00CF7658 /* gtest-death-test.h in Headers */,
 				404884390E2F799B00CF7658 /* gtest-message.h in Headers */,
 				4539C9340EC280AE00A70F4C /* gtest-param-test.h in Headers */,
 				F67D4F461C7F5DD00017C729 /* gtest.h in Headers */,
 				F67D4F441C7F5DD00017C729 /* gtest-port.h in Headers */,
 				4567C8181264FF71007740BE /* gtest-printers.h in Headers */,
 				F67D4F3E1C7F5D8B0017C729 /* gtest-port-arch.h in Headers */,
 				3BF6F2A50E79B616000F2EEE /* gtest-typed-test.h in Headers */,
 				4048843A0E2F799B00CF7658 /* gtest-spi.h in Headers */,
 				4048843B0E2F799B00CF7658 /* gtest.h in Headers */,
 				4048843C0E2F799B00CF7658 /* gtest_pred_impl.h in Headers */,
 				4048843D0E2F799B00CF7658 /* gtest_prod.h in Headers */,
 				224A12A30E9EADCC00BD17FD /* gtest-test-part.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXHeadersBuildPhase section */
 
 /* Begin PBXNativeTarget section */
 		40899F420FFA7184000B29AE /* gtest_unittest-framework */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */;
 			buildPhases = (
 				40899F400FFA7184000B29AE /* Sources */,
 				40899F410FFA7184000B29AE /* Frameworks */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 				40C849A0101A36F10083642A /* PBXTargetDependency */,
 			);
 			name = "gtest_unittest-framework";
 			productName = gtest_unittest;
 			productReference = 40899F430FFA7184000B29AE /* gtest_unittest-framework */;
 			productType = "com.apple.product-type.tool";
 		};
 		4089A0120FFACEFC000B29AE /* sample1_unittest-framework */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */;
 			buildPhases = (
 				4089A0100FFACEFC000B29AE /* Sources */,
 				4089A0110FFACEFC000B29AE /* Frameworks */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 				40C8499E101A36E50083642A /* PBXTargetDependency */,
 			);
 			name = "sample1_unittest-framework";
 			productName = sample1_unittest;
 			productReference = 4089A0130FFACEFC000B29AE /* sample1_unittest-framework */;
 			productType = "com.apple.product-type.tool";
 		};
 		40C848F9101A209C0083642A /* gtest-static */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */;
 			buildPhases = (
 				40C848F7101A209C0083642A /* Sources */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 			);
 			name = "gtest-static";
 			productName = "gtest-static";
 			productReference = 40C848FA101A209C0083642A /* libgtest.a */;
 			productType = "com.apple.product-type.library.static";
 		};
 		40C8490A101A217E0083642A /* gtest_main-static */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */;
 			buildPhases = (
 				40C84908101A217E0083642A /* Sources */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 			);
 			name = "gtest_main-static";
 			productName = "gtest_main-static";
 			productReference = 40C8490B101A217E0083642A /* libgtest_main.a */;
 			productType = "com.apple.product-type.library.static";
 		};
 		40C8497A101A36850083642A /* gtest_unittest-static */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */;
 			buildPhases = (
 				40C8497F101A36850083642A /* Sources */,
 				40C84981101A36850083642A /* Frameworks */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 				40C8497B101A36850083642A /* PBXTargetDependency */,
 				40C8497D101A36850083642A /* PBXTargetDependency */,
 			);
 			name = "gtest_unittest-static";
 			productName = gtest_unittest;
 			productReference = 40C84987101A36850083642A /* gtest_unittest */;
 			productType = "com.apple.product-type.tool";
 		};
 		40C84989101A36A60083642A /* sample1_unittest-static */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */;
 			buildPhases = (
 				40C8498E101A36A60083642A /* Sources */,
 				40C84991101A36A60083642A /* Frameworks */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 				40C8498A101A36A60083642A /* PBXTargetDependency */,
 				40C8498C101A36A60083642A /* PBXTargetDependency */,
 			);
 			name = "sample1_unittest-static";
 			productName = sample1_unittest;
 			productReference = 40C84997101A36A60083642A /* sample1_unittest-static */;
 			productType = "com.apple.product-type.tool";
 		};
 		8D07F2BC0486CC7A007CD1D0 /* gtest-framework */ = {
 			isa = PBXNativeTarget;
 			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */;
 			buildPhases = (
 				8D07F2C10486CC7A007CD1D0 /* Sources */,
 				8D07F2BD0486CC7A007CD1D0 /* Headers */,
 				404884A50E2F7C0400CF7658 /* Copy Headers Internal */,
 				F67D4F471C7F5DF60017C729 /* Copy Headers Internal Custom */,
 				8D07F2BF0486CC7A007CD1D0 /* Resources */,
 			);
 			buildRules = (
 			);
 			dependencies = (
 				40C44AE60E379922008FCC51 /* PBXTargetDependency */,
 				408BEC101046CFE900DEF522 /* PBXTargetDependency */,
 				40C8499C101A36DC0083642A /* PBXTargetDependency */,
 			);
 			name = "gtest-framework";
 			productInstallPath = "$(HOME)/Library/Frameworks";
 			productName = gtest;
 			productReference = 4539C8FF0EC27F6400A70F4C /* gtest.framework */;
 			productType = "com.apple.product-type.framework";
 		};
 /* End PBXNativeTarget section */
 
 /* Begin PBXProject section */
 		0867D690FE84028FC02AAC07 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
 				LastUpgradeCheck = 0460;
 			};
 			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */;
 			compatibilityVersion = "Xcode 3.2";
 			developmentRegion = English;
 			hasScannedForEncodings = 1;
 			knownRegions = (
 				English,
 				Japanese,
 				French,
 				German,
 				en,
 			);
 			mainGroup = 0867D691FE84028FC02AAC07 /* gtest */;
 			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
 			projectDirPath = "";
 			projectRoot = "";
 			targets = (
 				8D07F2BC0486CC7A007CD1D0 /* gtest-framework */,
 				40C848F9101A209C0083642A /* gtest-static */,
 				40C8490A101A217E0083642A /* gtest_main-static */,
 				40899F420FFA7184000B29AE /* gtest_unittest-framework */,
 				40C8497A101A36850083642A /* gtest_unittest-static */,
 				4089A0120FFACEFC000B29AE /* sample1_unittest-framework */,
 				40C84989101A36A60083642A /* sample1_unittest-static */,
 				3B238F5F0E828B5400846E11 /* Check */,
 				40C44ADC0E3798F4008FCC51 /* Version Info */,
 			);
 		};
 /* End PBXProject section */
 
 /* Begin PBXResourcesBuildPhase section */
 		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				404884500E2F799B00CF7658 /* README.md in Resources */,
+				404884AC0E2F7CD900CF7658 /* CHANGES in Resources */,
 				404884AD0E2F7CD900CF7658 /* CONTRIBUTORS in Resources */,
 				404884AE0E2F7CD900CF7658 /* LICENSE in Resources */,
 				40C84978101A36540083642A /* libgtest_main.a in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
 		3B238F5E0E828B5400846E11 /* ShellScript */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputPaths = (
 			);
 			outputPaths = (
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
 			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/bin/bash Scripts/runtests.sh";
 		};
 		40C44ADB0E3798F4008FCC51 /* Generate Version.h */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputPaths = (
 				"$(SRCROOT)/Scripts/versiongenerate.py",
 				"$(SRCROOT)/../configure.ac",
 			);
 			name = "Generate Version.h";
 			outputPaths = (
 				"$(PROJECT_TEMP_DIR)/Version.h",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
 			shellScript = "# Remember, this \"Run Script\" build phase will be executed from $SRCROOT\n/usr/bin/python Scripts/versiongenerate.py ../ $PROJECT_TEMP_DIR";
 		};
 /* End PBXShellScriptBuildPhase section */
 
 /* Begin PBXSourcesBuildPhase section */
 		40899F400FFA7184000B29AE /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40899F530FFA72A0000B29AE /* gtest_unittest.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		4089A0100FFACEFC000B29AE /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				4089A0440FFAD1BE000B29AE /* sample1.cc in Sources */,
 				4089A0460FFAD1BE000B29AE /* sample1_unittest.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C848F7101A209C0083642A /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C848FF101A21150083642A /* gtest-all.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C84908101A217E0083642A /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C84915101A21DF0083642A /* gtest_main.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C8497F101A36850083642A /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C84980101A36850083642A /* gtest_unittest.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		40C8498E101A36A60083642A /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40C8498F101A36A60083642A /* sample1.cc in Sources */,
 				40C84990101A36A60083642A /* sample1_unittest.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 				40899F3A0FFA70D4000B29AE /* gtest-all.cc in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
 /* End PBXSourcesBuildPhase section */
 
 /* Begin PBXTargetDependency section */
 		40899F9D0FFA740F000B29AE /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40899F420FFA7184000B29AE /* gtest_unittest-framework */;
 			targetProxy = 40899F9C0FFA740F000B29AE /* PBXContainerItemProxy */;
 		};
 		4089A0980FFAD34A000B29AE /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 4089A0120FFACEFC000B29AE /* sample1_unittest-framework */;
 			targetProxy = 4089A0970FFAD34A000B29AE /* PBXContainerItemProxy */;
 		};
 		408BEC101046CFE900DEF522 /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C848F9101A209C0083642A /* gtest-static */;
 			targetProxy = 408BEC0F1046CFE900DEF522 /* PBXContainerItemProxy */;
 		};
 		40C44AE60E379922008FCC51 /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C44ADC0E3798F4008FCC51 /* Version Info */;
 			targetProxy = 40C44AE50E379922008FCC51 /* PBXContainerItemProxy */;
 		};
 		40C8497B101A36850083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C848F9101A209C0083642A /* gtest-static */;
 			targetProxy = 40C8497C101A36850083642A /* PBXContainerItemProxy */;
 		};
 		40C8497D101A36850083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C8490A101A217E0083642A /* gtest_main-static */;
 			targetProxy = 40C8497E101A36850083642A /* PBXContainerItemProxy */;
 		};
 		40C8498A101A36A60083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C848F9101A209C0083642A /* gtest-static */;
 			targetProxy = 40C8498B101A36A60083642A /* PBXContainerItemProxy */;
 		};
 		40C8498C101A36A60083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C8490A101A217E0083642A /* gtest_main-static */;
 			targetProxy = 40C8498D101A36A60083642A /* PBXContainerItemProxy */;
 		};
 		40C8499C101A36DC0083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C8490A101A217E0083642A /* gtest_main-static */;
 			targetProxy = 40C8499B101A36DC0083642A /* PBXContainerItemProxy */;
 		};
 		40C8499E101A36E50083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
 			targetProxy = 40C8499D101A36E50083642A /* PBXContainerItemProxy */;
 		};
 		40C849A0101A36F10083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 8D07F2BC0486CC7A007CD1D0 /* gtest-framework */;
 			targetProxy = 40C8499F101A36F10083642A /* PBXContainerItemProxy */;
 		};
 		40C849F7101A43440083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C8497A101A36850083642A /* gtest_unittest-static */;
 			targetProxy = 40C849F6101A43440083642A /* PBXContainerItemProxy */;
 		};
 		40C849F9101A43490083642A /* PBXTargetDependency */ = {
 			isa = PBXTargetDependency;
 			target = 40C84989101A36A60083642A /* sample1_unittest-static */;
 			targetProxy = 40C849F8101A43490083642A /* PBXContainerItemProxy */;
 		};
 /* End PBXTargetDependency section */
 
 /* Begin XCBuildConfiguration section */
 		3B238F600E828B5400846E11 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = NO;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = Check;
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		3B238F610E828B5400846E11 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				COPY_PHASE_STRIP = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = Check;
 				SDKROOT = macosx;
 				ZERO_LINK = NO;
 			};
 			name = Release;
 		};
 		40899F450FFA7185000B29AE /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = ../;
 				PRODUCT_NAME = "gtest_unittest-framework";
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		40899F460FFA7185000B29AE /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = ../;
 				PRODUCT_NAME = "gtest_unittest-framework";
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		4089A0150FFACEFD000B29AE /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = "sample1_unittest-framework";
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		4089A0160FFACEFD000B29AE /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = "sample1_unittest-framework";
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		40C44ADF0E3798F4008FCC51 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				MACOSX_DEPLOYMENT_TARGET = 10.7;
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 				TARGET_NAME = gtest;
 			};
 			name = Debug;
 		};
 		40C44AE00E3798F4008FCC51 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				MACOSX_DEPLOYMENT_TARGET = 10.7;
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 				TARGET_NAME = gtest;
 			};
 			name = Release;
 		};
 		40C848FB101A209D0083642A /* Debug */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		40C848FC101A209D0083642A /* Release */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_INLINES_ARE_PRIVATE_EXTERN = YES;
 				GCC_SYMBOLS_PRIVATE_EXTERN = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		40C8490E101A217F0083642A /* Debug */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				PRODUCT_NAME = gtest_main;
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		40C8490F101A217F0083642A /* Release */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40899FB30FFA7567000B29AE /* StaticLibraryTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				PRODUCT_NAME = gtest_main;
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		40C84985101A36850083642A /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = ../;
 				PRODUCT_NAME = gtest_unittest;
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		40C84986101A36850083642A /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = ../;
 				PRODUCT_NAME = gtest_unittest;
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		40C84995101A36A60083642A /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = "sample1_unittest-static";
 				SDKROOT = macosx;
 			};
 			name = Debug;
 		};
 		40C84996101A36A60083642A /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				PRODUCT_NAME = "sample1_unittest-static";
 				SDKROOT = macosx;
 			};
 			name = Release;
 		};
 		4FADC24308B4156D00ABE55E /* Debug */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
 				DYLIB_CURRENT_VERSION = 1;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				INFOPLIST_FILE = Resources/Info.plist;
 				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
 				INFOPLIST_PREPROCESS = YES;
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 				VERSIONING_SYSTEM = "apple-generic";
 			};
 			name = Debug;
 		};
 		4FADC24408B4156D00ABE55E /* Release */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40D4CDF20E30E07400294801 /* FrameworkTarget.xcconfig */;
 			buildSettings = {
 				COMBINE_HIDPI_IMAGES = YES;
 				DYLIB_COMPATIBILITY_VERSION = 1;
 				DYLIB_CURRENT_VERSION = 1;
 				GCC_VERSION = com.apple.compilers.llvm.clang.1_0;
 				HEADER_SEARCH_PATHS = (
 					../,
 					../include/,
 				);
 				INFOPLIST_FILE = Resources/Info.plist;
 				INFOPLIST_PREFIX_HEADER = "$(PROJECT_TEMP_DIR)/Version.h";
 				INFOPLIST_PREPROCESS = YES;
 				PRODUCT_NAME = gtest;
 				SDKROOT = macosx;
 				VERSIONING_SYSTEM = "apple-generic";
 			};
 			name = Release;
 		};
 		4FADC24708B4156D00ABE55E /* Debug */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40D4CDF10E30E07400294801 /* DebugProject.xcconfig */;
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				MACOSX_DEPLOYMENT_TARGET = 10.7;
 			};
 			name = Debug;
 		};
 		4FADC24808B4156D00ABE55E /* Release */ = {
 			isa = XCBuildConfiguration;
 			baseConfigurationReference = 40D4CDF40E30E07400294801 /* ReleaseProject.xcconfig */;
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				MACOSX_DEPLOYMENT_TARGET = 10.7;
 			};
 			name = Release;
 		};
 /* End XCBuildConfiguration section */
 
 /* Begin XCConfigurationList section */
 		3B238FA30E828BB600846E11 /* Build configuration list for PBXAggregateTarget "Check" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				3B238F600E828B5400846E11 /* Debug */,
 				3B238F610E828B5400846E11 /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40899F4A0FFA71BC000B29AE /* Build configuration list for PBXNativeTarget "gtest_unittest-framework" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40899F450FFA7185000B29AE /* Debug */,
 				40899F460FFA7185000B29AE /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		4089A0240FFACF01000B29AE /* Build configuration list for PBXNativeTarget "sample1_unittest-framework" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				4089A0150FFACEFD000B29AE /* Debug */,
 				4089A0160FFACEFD000B29AE /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40C44AE40E379905008FCC51 /* Build configuration list for PBXAggregateTarget "Version Info" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40C44ADF0E3798F4008FCC51 /* Debug */,
 				40C44AE00E3798F4008FCC51 /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40C84902101A212E0083642A /* Build configuration list for PBXNativeTarget "gtest-static" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40C848FB101A209D0083642A /* Debug */,
 				40C848FC101A209D0083642A /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40C84912101A21D20083642A /* Build configuration list for PBXNativeTarget "gtest_main-static" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40C8490E101A217F0083642A /* Debug */,
 				40C8490F101A217F0083642A /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40C84984101A36850083642A /* Build configuration list for PBXNativeTarget "gtest_unittest-static" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40C84985101A36850083642A /* Debug */,
 				40C84986101A36850083642A /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		40C84994101A36A60083642A /* Build configuration list for PBXNativeTarget "sample1_unittest-static" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				40C84995101A36A60083642A /* Debug */,
 				40C84996101A36A60083642A /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "gtest-framework" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				4FADC24308B4156D00ABE55E /* Debug */,
 				4FADC24408B4156D00ABE55E /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "gtest" */ = {
 			isa = XCConfigurationList;
 			buildConfigurations = (
 				4FADC24708B4156D00ABE55E /* Debug */,
 				4FADC24808B4156D00ABE55E /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
 			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
 	};
 	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
 }