Restoring authorship annotation for <bulatman@yandex-team.ru>. Commit 1 of 2.

66 files changed, 15002 insertions, 15002 deletions

diff --git a/contrib/restricted/googletest/CONTRIBUTING.md b/contrib/restricted/googletest/CONTRIBUTING.md
index da45e4450c..77beda5f6d 100644
--- a/contrib/restricted/googletest/CONTRIBUTING.md
+++ b/contrib/restricted/googletest/CONTRIBUTING.md
@@ -1,130 +1,130 @@
-# How to become a contributor and submit your own code
-
-## Contributor License Agreements
-
-We'd love to accept your patches! Before we can take them, we have to jump a
-couple of legal hurdles.
-
-Please fill out either the individual or corporate Contributor License Agreement
-(CLA).
-
-*   If you are an individual writing original source code and you're sure you
-    own the intellectual property, then you'll need to sign an
-    [individual CLA](https://developers.google.com/open-source/cla/individual).
-*   If you work for a company that wants to allow you to contribute your work,
-    then you'll need to sign a
-    [corporate CLA](https://developers.google.com/open-source/cla/corporate).
-
-Follow either of the two links above to access the appropriate CLA and
-instructions for how to sign and return it. Once we receive it, we'll be able to
-accept your pull requests.
-
-## Are you a Googler?
-
-If you are a Googler, please make an attempt to submit an internal change rather
-than a GitHub Pull Request. If you are not able to submit an internal change a
-PR is acceptable as an alternative.
-
-## Contributing A Patch
-
-1.  Submit an issue describing your proposed change to the
-    [issue tracker](https://github.com/google/googletest/issues).
-2.  Please don't mix more than one logical change per submittal, because it
-    makes the history hard to follow. If you want to make a change that doesn't
-    have a corresponding issue in the issue tracker, please create one.
-3.  Also, coordinate with team members that are listed on the issue in question.
-    This ensures that work isn't being duplicated and communicating your plan
-    early also generally leads to better patches.
-4.  If your proposed change is accepted, and you haven't already done so, sign a
-    Contributor License Agreement (see details above).
-5.  Fork the desired repo, develop and test your code changes.
-6.  Ensure that your code adheres to the existing style in the sample to which
-    you are contributing.
-7.  Ensure that your code has an appropriate set of unit tests which all pass.
-8.  Submit a pull request.
-
-## The Google Test and Google Mock Communities
-
-The Google Test community exists primarily through the
-[discussion group](http://groups.google.com/group/googletestframework) and the
-GitHub repository. Likewise, the Google Mock community exists primarily through
-their own [discussion group](http://groups.google.com/group/googlemock). You are
-definitely encouraged to contribute to the discussion and you can also help us
-to keep the effectiveness of the group high by following and promoting the
-guidelines listed here.
-
-### Please Be Friendly
-
-Showing courtesy and respect to others is a vital part of the Google culture,
-and we strongly encourage everyone participating in Google Test development to
-join us in accepting nothing less. Of course, being courteous is not the same as
-failing to constructively disagree with each other, but it does mean that we
-should be respectful of each other when enumerating the 42 technical reasons
-that a particular proposal may not be the best choice. There's never a reason to
-be antagonistic or dismissive toward anyone who is sincerely trying to
-contribute to a discussion.
-
-Sure, C++ testing is serious business and all that, but it's also a lot of fun.
-Let's keep it that way. Let's strive to be one of the friendliest communities in
-all of open source.
-
-As always, discuss Google Test in the official GoogleTest discussion group. You
-don't have to actually submit code in order to sign up. Your participation
-itself is a valuable contribution.
-
-## Style
-
-To keep the source consistent, readable, diffable and easy to merge, we use a
-fairly rigid coding style, as defined by the
-[google-styleguide](https://github.com/google/styleguide) project. All patches
-will be expected to conform to the style outlined
-[here](https://google.github.io/styleguide/cppguide.html). Use
-[.clang-format](https://github.com/google/googletest/blob/master/.clang-format)
-to check your formatting.
-
-## Requirements for Contributors
-
-If you plan to contribute a patch, you need to build Google Test, Google Mock,
-and their own tests from a git checkout, which has further requirements:
-
-*   [Python](https://www.python.org/) v2.3 or newer (for running some of the
-    tests and re-generating certain source files from templates)
-*   [CMake](https://cmake.org/) v2.8.12 or newer
-
-## Developing Google Test and Google Mock
-
-This section discusses how to make your own changes to the Google Test project.
-
-### Testing Google Test and Google Mock Themselves
-
-To make sure your changes work as intended and don't break existing
-functionality, you'll want to compile and run Google Test and GoogleMock's own
-tests. For that you can use CMake:
-
-    mkdir mybuild
-    cd mybuild
-    cmake -Dgtest_build_tests=ON -Dgmock_build_tests=ON ${GTEST_REPO_DIR}
-
-To choose between building only Google Test or Google Mock, you may modify your
-cmake command to be one of each
-
-    cmake -Dgtest_build_tests=ON ${GTEST_DIR} # sets up Google Test tests
-    cmake -Dgmock_build_tests=ON ${GMOCK_DIR} # sets up Google Mock tests
-
-Make sure you have Python installed, as some of Google Test's tests are written
-in Python. If the cmake command complains about not being able to find Python
-(`Could NOT find PythonInterp (missing: PYTHON_EXECUTABLE)`), try telling it
-explicitly where your Python executable can be found:
-
-    cmake -DPYTHON_EXECUTABLE=path/to/python ...
-
-Next, you can build Google Test and / or Google Mock and all desired tests. On
-\*nix, this is usually done by
-
-    make
-
-To run the tests, do
-
-    make test
-
-All tests should pass.
+# How to become a contributor and submit your own code 
+ 
+## Contributor License Agreements 
+ 
+We'd love to accept your patches! Before we can take them, we have to jump a 
+couple of legal hurdles. 
+ 
+Please fill out either the individual or corporate Contributor License Agreement 
+(CLA). 
+ 
+*   If you are an individual writing original source code and you're sure you 
+    own the intellectual property, then you'll need to sign an 
+    [individual CLA](https://developers.google.com/open-source/cla/individual). 
+*   If you work for a company that wants to allow you to contribute your work, 
+    then you'll need to sign a 
+    [corporate CLA](https://developers.google.com/open-source/cla/corporate). 
+ 
+Follow either of the two links above to access the appropriate CLA and 
+instructions for how to sign and return it. Once we receive it, we'll be able to 
+accept your pull requests. 
+ 
+## Are you a Googler? 
+ 
+If you are a Googler, please make an attempt to submit an internal change rather 
+than a GitHub Pull Request. If you are not able to submit an internal change a 
+PR is acceptable as an alternative. 
+ 
+## Contributing A Patch 
+ 
+1.  Submit an issue describing your proposed change to the 
+    [issue tracker](https://github.com/google/googletest/issues). 
+2.  Please don't mix more than one logical change per submittal, because it 
+    makes the history hard to follow. If you want to make a change that doesn't 
+    have a corresponding issue in the issue tracker, please create one. 
+3.  Also, coordinate with team members that are listed on the issue in question. 
+    This ensures that work isn't being duplicated and communicating your plan 
+    early also generally leads to better patches. 
+4.  If your proposed change is accepted, and you haven't already done so, sign a 
+    Contributor License Agreement (see details above). 
+5.  Fork the desired repo, develop and test your code changes. 
+6.  Ensure that your code adheres to the existing style in the sample to which 
+    you are contributing. 
+7.  Ensure that your code has an appropriate set of unit tests which all pass. 
+8.  Submit a pull request. 
+ 
+## The Google Test and Google Mock Communities 
+ 
+The Google Test community exists primarily through the 
+[discussion group](http://groups.google.com/group/googletestframework) and the 
+GitHub repository. Likewise, the Google Mock community exists primarily through 
+their own [discussion group](http://groups.google.com/group/googlemock). You are 
+definitely encouraged to contribute to the discussion and you can also help us 
+to keep the effectiveness of the group high by following and promoting the 
+guidelines listed here. 
+ 
+### Please Be Friendly 
+ 
+Showing courtesy and respect to others is a vital part of the Google culture, 
+and we strongly encourage everyone participating in Google Test development to 
+join us in accepting nothing less. Of course, being courteous is not the same as 
+failing to constructively disagree with each other, but it does mean that we 
+should be respectful of each other when enumerating the 42 technical reasons 
+that a particular proposal may not be the best choice. There's never a reason to 
+be antagonistic or dismissive toward anyone who is sincerely trying to 
+contribute to a discussion. 
+ 
+Sure, C++ testing is serious business and all that, but it's also a lot of fun. 
+Let's keep it that way. Let's strive to be one of the friendliest communities in 
+all of open source. 
+ 
+As always, discuss Google Test in the official GoogleTest discussion group. You 
+don't have to actually submit code in order to sign up. Your participation 
+itself is a valuable contribution. 
+ 
+## Style 
+ 
+To keep the source consistent, readable, diffable and easy to merge, we use a 
+fairly rigid coding style, as defined by the 
+[google-styleguide](https://github.com/google/styleguide) project. All patches 
+will be expected to conform to the style outlined 
+[here](https://google.github.io/styleguide/cppguide.html). Use 
+[.clang-format](https://github.com/google/googletest/blob/master/.clang-format) 
+to check your formatting. 
+ 
+## Requirements for Contributors 
+ 
+If you plan to contribute a patch, you need to build Google Test, Google Mock, 
+and their own tests from a git checkout, which has further requirements: 
+ 
+*   [Python](https://www.python.org/) v2.3 or newer (for running some of the 
+    tests and re-generating certain source files from templates) 
+*   [CMake](https://cmake.org/) v2.8.12 or newer 
+ 
+## Developing Google Test and Google Mock 
+ 
+This section discusses how to make your own changes to the Google Test project. 
+ 
+### Testing Google Test and Google Mock Themselves 
+ 
+To make sure your changes work as intended and don't break existing 
+functionality, you'll want to compile and run Google Test and GoogleMock's own 
+tests. For that you can use CMake: 
+ 
+    mkdir mybuild 
+    cd mybuild 
+    cmake -Dgtest_build_tests=ON -Dgmock_build_tests=ON ${GTEST_REPO_DIR} 
+ 
+To choose between building only Google Test or Google Mock, you may modify your 
+cmake command to be one of each 
+ 
+    cmake -Dgtest_build_tests=ON ${GTEST_DIR} # sets up Google Test tests 
+    cmake -Dgmock_build_tests=ON ${GMOCK_DIR} # sets up Google Mock tests 
+ 
+Make sure you have Python installed, as some of Google Test's tests are written 
+in Python. If the cmake command complains about not being able to find Python 
+(`Could NOT find PythonInterp (missing: PYTHON_EXECUTABLE)`), try telling it 
+explicitly where your Python executable can be found: 
+ 
+    cmake -DPYTHON_EXECUTABLE=path/to/python ... 
+ 
+Next, you can build Google Test and / or Google Mock and all desired tests. On 
+\*nix, this is usually done by 
+ 
+    make 
+ 
+To run the tests, do 
+ 
+    make test 
+ 
+All tests should pass. 
diff --git a/contrib/restricted/googletest/CONTRIBUTORS b/contrib/restricted/googletest/CONTRIBUTORS
index 76db0b40ff..cfd74a7b34 100644
--- a/contrib/restricted/googletest/CONTRIBUTORS
+++ b/contrib/restricted/googletest/CONTRIBUTORS
@@ -1,63 +1,63 @@
-# This file contains a list of people who've made non-trivial
-# contribution to the Google C++ Testing Framework project.  People
-# who commit code to the project are encouraged to add their names
-# here.  Please keep the list sorted by first names.
-
-Ajay Joshi <jaj@google.com>
-Balázs Dán <balazs.dan@gmail.com>
-Benoit Sigoure <tsuna@google.com>
-Bharat Mediratta <bharat@menalto.com>
-Bogdan Piloca <boo@google.com>
-Chandler Carruth <chandlerc@google.com>
-Chris Prince <cprince@google.com>
-Chris Taylor <taylorc@google.com>
-Dan Egnor <egnor@google.com>
-Dave MacLachlan <dmaclach@gmail.com>
-David Anderson <danderson@google.com>
-Dean Sturtevant
-Eric Roman <eroman@chromium.org>
-Gene Volovich <gv@cite.com>
-Hady Zalek <hady.zalek@gmail.com>
-Hal Burch <gmock@hburch.com>
-Jeffrey Yasskin <jyasskin@google.com>
-Jim Keller <jimkeller@google.com>
-Joe Walnes <joe@truemesh.com>
-Jon Wray <jwray@google.com>
-Jói Sigurðsson <joi@google.com>
-Keir Mierle <mierle@gmail.com>
-Keith Ray <keith.ray@gmail.com>
-Kenton Varda <kenton@google.com>
-Kostya Serebryany <kcc@google.com>
-Krystian Kuzniarek <krystian.kuzniarek@gmail.com>
-Lev Makhlis
-Manuel Klimek <klimek@google.com>
-Mario Tanev <radix@google.com>
-Mark Paskin
-Markus Heule <markus.heule@gmail.com>
-Matthew Simmons <simmonmt@acm.org>
-Mika Raento <mikie@iki.fi>
-Mike Bland <mbland@google.com>
-Miklós Fazekas <mfazekas@szemafor.com>
-Neal Norwitz <nnorwitz@gmail.com>
-Nermin Ozkiranartli <nermin@google.com>
-Owen Carlsen <ocarlsen@google.com>
-Paneendra Ba <paneendra@google.com>
-Pasi Valminen <pasi.valminen@gmail.com>
-Patrick Hanna <phanna@google.com>
-Patrick Riley <pfr@google.com>
-Paul Menage <menage@google.com>
-Peter Kaminski <piotrk@google.com>
-Piotr Kaminski <piotrk@google.com>
-Preston Jackson <preston.a.jackson@gmail.com>
-Rainer Klaffenboeck <rainer.klaffenboeck@dynatrace.com>
-Russ Cox <rsc@google.com>
-Russ Rufer <russ@pentad.com>
-Sean Mcafee <eefacm@gmail.com>
-Sigurður Ásgeirsson <siggi@google.com>
-Sverre Sundsdal <sundsdal@gmail.com>
-Takeshi Yoshino <tyoshino@google.com>
-Tracy Bialik <tracy@pentad.com>
-Vadim Berman <vadimb@google.com>
-Vlad Losev <vladl@google.com>
-Wolfgang Klier <wklier@google.com>
-Zhanyong Wan <wan@google.com>
+# This file contains a list of people who've made non-trivial 
+# contribution to the Google C++ Testing Framework project.  People 
+# who commit code to the project are encouraged to add their names 
+# here.  Please keep the list sorted by first names. 
+ 
+Ajay Joshi <jaj@google.com> 
+Balázs Dán <balazs.dan@gmail.com> 
+Benoit Sigoure <tsuna@google.com> 
+Bharat Mediratta <bharat@menalto.com> 
+Bogdan Piloca <boo@google.com> 
+Chandler Carruth <chandlerc@google.com> 
+Chris Prince <cprince@google.com> 
+Chris Taylor <taylorc@google.com> 
+Dan Egnor <egnor@google.com> 
+Dave MacLachlan <dmaclach@gmail.com> 
+David Anderson <danderson@google.com> 
+Dean Sturtevant 
+Eric Roman <eroman@chromium.org> 
+Gene Volovich <gv@cite.com> 
+Hady Zalek <hady.zalek@gmail.com> 
+Hal Burch <gmock@hburch.com> 
+Jeffrey Yasskin <jyasskin@google.com> 
+Jim Keller <jimkeller@google.com> 
+Joe Walnes <joe@truemesh.com> 
+Jon Wray <jwray@google.com> 
+Jói Sigurðsson <joi@google.com> 
+Keir Mierle <mierle@gmail.com> 
+Keith Ray <keith.ray@gmail.com> 
+Kenton Varda <kenton@google.com> 
+Kostya Serebryany <kcc@google.com> 
+Krystian Kuzniarek <krystian.kuzniarek@gmail.com> 
+Lev Makhlis 
+Manuel Klimek <klimek@google.com> 
+Mario Tanev <radix@google.com> 
+Mark Paskin 
+Markus Heule <markus.heule@gmail.com> 
+Matthew Simmons <simmonmt@acm.org> 
+Mika Raento <mikie@iki.fi> 
+Mike Bland <mbland@google.com> 
+Miklós Fazekas <mfazekas@szemafor.com> 
+Neal Norwitz <nnorwitz@gmail.com> 
+Nermin Ozkiranartli <nermin@google.com> 
+Owen Carlsen <ocarlsen@google.com> 
+Paneendra Ba <paneendra@google.com> 
+Pasi Valminen <pasi.valminen@gmail.com> 
+Patrick Hanna <phanna@google.com> 
+Patrick Riley <pfr@google.com> 
+Paul Menage <menage@google.com> 
+Peter Kaminski <piotrk@google.com> 
+Piotr Kaminski <piotrk@google.com> 
+Preston Jackson <preston.a.jackson@gmail.com> 
+Rainer Klaffenboeck <rainer.klaffenboeck@dynatrace.com> 
+Russ Cox <rsc@google.com> 
+Russ Rufer <russ@pentad.com> 
+Sean Mcafee <eefacm@gmail.com> 
+Sigurður Ásgeirsson <siggi@google.com> 
+Sverre Sundsdal <sundsdal@gmail.com> 
+Takeshi Yoshino <tyoshino@google.com> 
+Tracy Bialik <tracy@pentad.com> 
+Vadim Berman <vadimb@google.com> 
+Vlad Losev <vladl@google.com> 
+Wolfgang Klier <wklier@google.com> 
+Zhanyong Wan <wan@google.com> 
diff --git a/contrib/restricted/googletest/LICENSE b/contrib/restricted/googletest/LICENSE
index 1941a11f8c..4b47bc80e7 100644
--- a/contrib/restricted/googletest/LICENSE
+++ b/contrib/restricted/googletest/LICENSE
@@ -1,28 +1,28 @@
-Copyright 2008, 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.
+Copyright 2008, 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. 
diff --git a/contrib/restricted/googletest/README.md b/contrib/restricted/googletest/README.md
index 7d872a57ed..0ffb46c2a6 100644
--- a/contrib/restricted/googletest/README.md
+++ b/contrib/restricted/googletest/README.md
@@ -1,140 +1,140 @@
-# GoogleTest
-
-### Announcements
-
-#### Live at Head
-
-GoogleTest now follows the
-[Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support).
-We recommend using the latest commit in the `master` branch in your projects.
-
-#### Documentation Updates
-
-Our documentation is now live on GitHub Pages at
-https://google.github.io/googletest/. We recommend browsing the documentation on
-GitHub Pages rather than directly in the repository.
-
-#### Release 1.10.x
-
-[Release 1.10.x](https://github.com/google/googletest/releases/tag/release-1.10.0)
-is now available.
-
-#### Coming Soon
-
-*   We are planning to take a dependency on
-    [Abseil](https://github.com/abseil/abseil-cpp).
-*   More documentation improvements are planned.
-
-## Welcome to **GoogleTest**, 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.
-
-### Getting Started
-
-See the [GoogleTest User's Guide](https://google.github.io/googletest/) for
-documentation. We recommend starting with the
-[GoogleTest Primer](https://google.github.io/googletest/primer.html).
-
-More information about building GoogleTest can be found at
-[googletest/README.md](googletest/README.md).
-
-## 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.
-
-## Supported Platforms
-
-GoogleTest requires a codebase and compiler compliant with the C++11 standard or
-newer.
-
-The GoogleTest code is officially supported on the following platforms.
-Operating systems or tools not listed below are community-supported. For
-community-supported platforms, patches that do not complicate the code may be
-considered.
-
-If you notice any problems on your platform, please file an issue on the
-[GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues).
-Pull requests containing fixes are welcome!
-
-### Operating Systems
-
-*   Linux
-*   macOS
-*   Windows
-
-### Compilers
-
-*   gcc 5.0+
-*   clang 5.0+
-*   MSVC 2015+
-
-**macOS users:** Xcode 9.3+ provides clang 5.0+.
-
-### Build Systems
-
-*   [Bazel](https://bazel.build/)
-*   [CMake](https://cmake.org/)
-
-**Note:** Bazel is the build system used by the team internally and in tests.
-CMake is supported on a best-effort basis and by the community.
-
-## Who Is Using GoogleTest?
-
-In addition to many internal projects at Google, GoogleTest 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.
-
-## 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.
-
-[GoogleTest UI](https://github.com/ospector/gtest-gbar) is a 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 GoogleTest 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 GoogleTest in a tree view, and run/debug
-your tests.
-
-[C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS
-Code extension allowing to view GoogleTest in a tree view, and run/debug your
-tests.
-
-[Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser
-that generates stub code for GoogleTest.
-
-## Contributing Changes
-
-Please read
-[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/master/CONTRIBUTING.md)
-for details on how to contribute to this project.
-
-Happy testing!
+# GoogleTest 
+ 
+### Announcements 
+ 
+#### Live at Head 
+ 
+GoogleTest now follows the 
+[Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support). 
+We recommend using the latest commit in the `master` branch in your projects. 
+ 
+#### Documentation Updates 
+ 
+Our documentation is now live on GitHub Pages at 
+https://google.github.io/googletest/. We recommend browsing the documentation on 
+GitHub Pages rather than directly in the repository. 
+ 
+#### Release 1.10.x 
+ 
+[Release 1.10.x](https://github.com/google/googletest/releases/tag/release-1.10.0) 
+is now available. 
+ 
+#### Coming Soon 
+ 
+*   We are planning to take a dependency on 
+    [Abseil](https://github.com/abseil/abseil-cpp). 
+*   More documentation improvements are planned. 
+ 
+## Welcome to **GoogleTest**, 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. 
+ 
+### Getting Started 
+ 
+See the [GoogleTest User's Guide](https://google.github.io/googletest/) for 
+documentation. We recommend starting with the 
+[GoogleTest Primer](https://google.github.io/googletest/primer.html). 
+ 
+More information about building GoogleTest can be found at 
+[googletest/README.md](googletest/README.md). 
+ 
+## 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. 
+ 
+## Supported Platforms 
+ 
+GoogleTest requires a codebase and compiler compliant with the C++11 standard or 
+newer. 
+ 
+The GoogleTest code is officially supported on the following platforms. 
+Operating systems or tools not listed below are community-supported. For 
+community-supported platforms, patches that do not complicate the code may be 
+considered. 
+ 
+If you notice any problems on your platform, please file an issue on the 
+[GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues). 
+Pull requests containing fixes are welcome! 
+ 
+### Operating Systems 
+ 
+*   Linux 
+*   macOS 
+*   Windows 
+ 
+### Compilers 
+ 
+*   gcc 5.0+ 
+*   clang 5.0+ 
+*   MSVC 2015+ 
+ 
+**macOS users:** Xcode 9.3+ provides clang 5.0+. 
+ 
+### Build Systems 
+ 
+*   [Bazel](https://bazel.build/) 
+*   [CMake](https://cmake.org/) 
+ 
+**Note:** Bazel is the build system used by the team internally and in tests. 
+CMake is supported on a best-effort basis and by the community. 
+ 
+## Who Is Using GoogleTest? 
+ 
+In addition to many internal projects at Google, GoogleTest 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. 
+ 
+## 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. 
+ 
+[GoogleTest UI](https://github.com/ospector/gtest-gbar) is a 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 GoogleTest 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 GoogleTest in a tree view, and run/debug 
+your tests. 
+ 
+[C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS 
+Code extension allowing to view GoogleTest in a tree view, and run/debug your 
+tests. 
+ 
+[Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser 
+that generates stub code for GoogleTest. 
+ 
+## Contributing Changes 
+ 
+Please read 
+[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/master/CONTRIBUTING.md) 
+for details on how to contribute to this project. 
+ 
+Happy testing! 
diff --git a/contrib/restricted/googletest/googlemock/README.md b/contrib/restricted/googletest/googlemock/README.md
index ead688325d..56b714057b 100644
--- a/contrib/restricted/googletest/googlemock/README.md
+++ b/contrib/restricted/googletest/googlemock/README.md
@@ -1,44 +1,44 @@
-# Googletest Mocking (gMock) Framework
-
-### Overview
-
-Google's framework for writing and using C++ mock classes. It can help you
-derive better designs of your system and write better tests.
-
-It is inspired by:
-
-*   [jMock](http://www.jmock.org/)
-*   [EasyMock](http://www.easymock.org/)
-*   [Hamcrest](http://code.google.com/p/hamcrest/)
-
-It is designed with C++'s specifics in mind.
-
-gMock:
-
--   Provides a declarative syntax for defining mocks.
--   Can define partial (hybrid) mocks, which are a cross of real and mock
-    objects.
--   Handles functions of arbitrary types and overloaded functions.
--   Comes with a rich set of matchers for validating function arguments.
--   Uses an intuitive syntax for controlling the behavior of a mock.
--   Does automatic verification of expectations (no record-and-replay needed).
--   Allows arbitrary (partial) ordering constraints on function calls to be
-    expressed.
--   Lets a user extend it by defining new matchers and actions.
--   Does not use exceptions.
--   Is easy to learn and use.
-
-Details and examples can be found here:
-
-*   [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html)
-*   [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html)
-*   [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html)
-*   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html)
-
-Please note that code under scripts/generator/ is from the
-[cppclean project](http://code.google.com/p/cppclean/) and under the Apache
-License, which is different from GoogleMock's license.
-
-GoogleMock is a part of
-[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
-subject to the same requirements.
+# Googletest Mocking (gMock) Framework 
+ 
+### Overview 
+ 
+Google's framework for writing and using C++ mock classes. It can help you 
+derive better designs of your system and write better tests. 
+ 
+It is inspired by: 
+ 
+*   [jMock](http://www.jmock.org/) 
+*   [EasyMock](http://www.easymock.org/) 
+*   [Hamcrest](http://code.google.com/p/hamcrest/) 
+ 
+It is designed with C++'s specifics in mind. 
+ 
+gMock: 
+ 
+-   Provides a declarative syntax for defining mocks. 
+-   Can define partial (hybrid) mocks, which are a cross of real and mock 
+    objects. 
+-   Handles functions of arbitrary types and overloaded functions. 
+-   Comes with a rich set of matchers for validating function arguments. 
+-   Uses an intuitive syntax for controlling the behavior of a mock. 
+-   Does automatic verification of expectations (no record-and-replay needed). 
+-   Allows arbitrary (partial) ordering constraints on function calls to be 
+    expressed. 
+-   Lets a user extend it by defining new matchers and actions. 
+-   Does not use exceptions. 
+-   Is easy to learn and use. 
+ 
+Details and examples can be found here: 
+ 
+*   [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html) 
+*   [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html) 
+*   [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html) 
+*   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html) 
+ 
+Please note that code under scripts/generator/ is from the 
+[cppclean project](http://code.google.com/p/cppclean/) and under the Apache 
+License, which is different from GoogleMock's license. 
+ 
+GoogleMock is a part of 
+[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a 
+subject to the same requirements. 
diff --git a/contrib/restricted/googletest/googlemock/gmock_main/ya.make b/contrib/restricted/googletest/googlemock/gmock_main/ya.make
index eb95d44b72..649d7c4f18 100644
--- a/contrib/restricted/googletest/googlemock/gmock_main/ya.make
+++ b/contrib/restricted/googletest/googlemock/gmock_main/ya.make
@@ -12,16 +12,16 @@ LICENSE(BSD-3-Clause)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/restricted/googletest/googlemock
-    contrib/restricted/googletest/googletest
+    contrib/restricted/googletest/googlemock 
+    contrib/restricted/googletest/googletest 
 )
 
-ADDINCL(
-    GLOBAL contrib/restricted/googletest/googlemock/include
-    GLOBAL contrib/restricted/googletest/googletest/include
-    contrib/restricted/googletest/googlemock
-    contrib/restricted/googletest/googletest
-)
+ADDINCL( 
+    GLOBAL contrib/restricted/googletest/googlemock/include 
+    GLOBAL contrib/restricted/googletest/googletest/include 
+    contrib/restricted/googletest/googlemock 
+    contrib/restricted/googletest/googletest 
+) 
 
 NO_COMPILER_WARNINGS()
 
@@ -33,7 +33,7 @@ CFLAGS(
     GLOBAL -DGTEST_HAS_STD_WSTRING=1
 )
 
-SRCDIR(contrib/restricted/googletest/googlemock/src)
+SRCDIR(contrib/restricted/googletest/googlemock/src) 
 
 SRCS(
     GLOBAL gmock_main.cc
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-actions.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-actions.h
index f2393bd3af..88a2e779a5 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-actions.h
@@ -27,128 +27,128 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
-// The ACTION* family of macros can be used in a namespace scope to
-// define custom actions easily.  The syntax:
-//
-//   ACTION(name) { statements; }
-//
-// will define an action with the given name that executes the
-// statements.  The value returned by the statements will be used as
-// the return value of the action.  Inside the statements, you can
-// refer to the K-th (0-based) argument of the mock function by
-// 'argK', and refer to its type by 'argK_type'.  For example:
-//
-//   ACTION(IncrementArg1) {
-//     arg1_type temp = arg1;
-//     return ++(*temp);
-//   }
-//
-// allows you to write
-//
-//   ...WillOnce(IncrementArg1());
-//
-// You can also refer to the entire argument tuple and its type by
-// 'args' and 'args_type', and refer to the mock function type and its
-// return type by 'function_type' and 'return_type'.
-//
-// Note that you don't need to specify the types of the mock function
-// arguments.  However rest assured that your code is still type-safe:
-// you'll get a compiler error if *arg1 doesn't support the ++
-// operator, or if the type of ++(*arg1) isn't compatible with the
-// mock function's return type, for example.
-//
-// Sometimes you'll want to parameterize the action.   For that you can use
-// another macro:
-//
-//   ACTION_P(name, param_name) { statements; }
-//
-// For example:
-//
-//   ACTION_P(Add, n) { return arg0 + n; }
-//
-// will allow you to write:
-//
-//   ...WillOnce(Add(5));
-//
-// Note that you don't need to provide the type of the parameter
-// either.  If you need to reference the type of a parameter named
-// 'foo', you can write 'foo_type'.  For example, in the body of
-// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
-// of 'n'.
-//
-// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
-// multi-parameter actions.
-//
-// For the purpose of typing, you can view
-//
-//   ACTION_Pk(Foo, p1, ..., pk) { ... }
-//
-// as shorthand for
-//
-//   template <typename p1_type, ..., typename pk_type>
-//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
-//
-// In particular, you can provide the template type arguments
-// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
-// although usually you can rely on the compiler to infer the types
-// for you automatically.  You can assign the result of expression
-// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
-// pk_type>.  This can be useful when composing actions.
-//
-// You can also overload actions with different numbers of parameters:
-//
-//   ACTION_P(Plus, a) { ... }
-//   ACTION_P2(Plus, a, b) { ... }
-//
-// While it's tempting to always use the ACTION* macros when defining
-// a new action, you should also consider implementing ActionInterface
-// or using MakePolymorphicAction() instead, especially if you need to
-// use the action a lot.  While these approaches require more work,
-// they give you more control on the types of the mock function
-// arguments and the action parameters, which in general leads to
-// better compiler error messages that pay off in the long run.  They
-// also allow overloading actions based on parameter types (as opposed
-// to just based on the number of parameters).
-//
-// CAVEAT:
-//
-// ACTION*() can only be used in a namespace scope as templates cannot be
-// declared inside of a local class.
-// Users can, however, define any local functors (e.g. a lambda) that
-// can be used as actions.
-//
-// MORE INFORMATION:
-//
-// To learn more about using these macros, please search for 'ACTION' on
-// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
-
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+// The ACTION* family of macros can be used in a namespace scope to 
+// define custom actions easily.  The syntax: 
+// 
+//   ACTION(name) { statements; } 
+// 
+// will define an action with the given name that executes the 
+// statements.  The value returned by the statements will be used as 
+// the return value of the action.  Inside the statements, you can 
+// refer to the K-th (0-based) argument of the mock function by 
+// 'argK', and refer to its type by 'argK_type'.  For example: 
+// 
+//   ACTION(IncrementArg1) { 
+//     arg1_type temp = arg1; 
+//     return ++(*temp); 
+//   } 
+// 
+// allows you to write 
+// 
+//   ...WillOnce(IncrementArg1()); 
+// 
+// You can also refer to the entire argument tuple and its type by 
+// 'args' and 'args_type', and refer to the mock function type and its 
+// return type by 'function_type' and 'return_type'. 
+// 
+// Note that you don't need to specify the types of the mock function 
+// arguments.  However rest assured that your code is still type-safe: 
+// you'll get a compiler error if *arg1 doesn't support the ++ 
+// operator, or if the type of ++(*arg1) isn't compatible with the 
+// mock function's return type, for example. 
+// 
+// Sometimes you'll want to parameterize the action.   For that you can use 
+// another macro: 
+// 
+//   ACTION_P(name, param_name) { statements; } 
+// 
+// For example: 
+// 
+//   ACTION_P(Add, n) { return arg0 + n; } 
+// 
+// will allow you to write: 
+// 
+//   ...WillOnce(Add(5)); 
+// 
+// Note that you don't need to provide the type of the parameter 
+// either.  If you need to reference the type of a parameter named 
+// 'foo', you can write 'foo_type'.  For example, in the body of 
+// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type 
+// of 'n'. 
+// 
+// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support 
+// multi-parameter actions. 
+// 
+// For the purpose of typing, you can view 
+// 
+//   ACTION_Pk(Foo, p1, ..., pk) { ... } 
+// 
+// as shorthand for 
+// 
+//   template <typename p1_type, ..., typename pk_type> 
+//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... } 
+// 
+// In particular, you can provide the template type arguments 
+// explicitly when invoking Foo(), as in Foo<long, bool>(5, false); 
+// although usually you can rely on the compiler to infer the types 
+// for you automatically.  You can assign the result of expression 
+// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ..., 
+// pk_type>.  This can be useful when composing actions. 
+// 
+// You can also overload actions with different numbers of parameters: 
+// 
+//   ACTION_P(Plus, a) { ... } 
+//   ACTION_P2(Plus, a, b) { ... } 
+// 
+// While it's tempting to always use the ACTION* macros when defining 
+// a new action, you should also consider implementing ActionInterface 
+// or using MakePolymorphicAction() instead, especially if you need to 
+// use the action a lot.  While these approaches require more work, 
+// they give you more control on the types of the mock function 
+// arguments and the action parameters, which in general leads to 
+// better compiler error messages that pay off in the long run.  They 
+// also allow overloading actions based on parameter types (as opposed 
+// to just based on the number of parameters). 
+// 
+// CAVEAT: 
+// 
+// ACTION*() can only be used in a namespace scope as templates cannot be 
+// declared inside of a local class. 
+// Users can, however, define any local functors (e.g. a lambda) that 
+// can be used as actions. 
+// 
+// MORE INFORMATION: 
+// 
+// To learn more about using these macros, please search for 'ACTION' on 
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md 
+
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 
 
 #ifndef _WIN32_WCE
 # include <errno.h>
 #endif
 
 #include <algorithm>
-#include <functional>
-#include <memory>
+#include <functional> 
+#include <memory> 
 #include <string>
-#include <tuple>
-#include <type_traits>
-#include <utility>
+#include <tuple> 
+#include <type_traits> 
+#include <utility> 
 
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gmock/internal/gmock-port.h"
-#include "gmock/internal/gmock-pp.h"
+#include "gmock/internal/gmock-pp.h" 
 
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
+#ifdef _MSC_VER 
+# pragma warning(push) 
+# pragma warning(disable:4100) 
 #endif
 
 namespace testing {
@@ -194,8 +194,8 @@ struct BuiltInDefaultValueGetter<T, false> {
 template <typename T>
 class BuiltInDefaultValue {
  public:
-  // This function returns true if and only if type T has a built-in default
-  // value.
+  // This function returns true if and only if type T has a built-in default 
+  // value. 
   static bool Exists() {
     return ::std::is_default_constructible<T>::value;
   }
@@ -221,7 +221,7 @@ template <typename T>
 class BuiltInDefaultValue<T*> {
  public:
   static bool Exists() { return true; }
-  static T* Get() { return nullptr; }
+  static T* Get() { return nullptr; } 
 };
 
 // The following specializations define the default values for
@@ -257,17 +257,17 @@ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
-GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT 
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT 
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
 GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
 
 #undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
 
-// Simple two-arg form of std::disjunction.
-template <typename P, typename Q>
-using disjunction = typename ::std::conditional<P::value, P, Q>::type;
-
+// Simple two-arg form of std::disjunction. 
+template <typename P, typename Q> 
+using disjunction = typename ::std::conditional<P::value, P, Q>::type; 
+ 
 }  // namespace internal
 
 // When an unexpected function call is encountered, Google Mock will
@@ -305,11 +305,11 @@ class DefaultValue {
   // Unsets the default value for type T.
   static void Clear() {
     delete producer_;
-    producer_ = nullptr;
+    producer_ = nullptr; 
   }
 
-  // Returns true if and only if the user has set the default value for type T.
-  static bool IsSet() { return producer_ != nullptr; }
+  // Returns true if and only if the user has set the default value for type T. 
+  static bool IsSet() { return producer_ != nullptr; } 
 
   // Returns true if T has a default return value set by the user or there
   // exists a built-in default value.
@@ -321,8 +321,8 @@ class DefaultValue {
   // otherwise returns the built-in default value. Requires that Exists()
   // is true, which ensures that the return value is well-defined.
   static T Get() {
-    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
-                                : producer_->Produce();
+    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get() 
+                                : producer_->Produce(); 
   }
 
  private:
@@ -335,7 +335,7 @@ class DefaultValue {
   class FixedValueProducer : public ValueProducer {
    public:
     explicit FixedValueProducer(T value) : value_(value) {}
-    T Produce() override { return value_; }
+    T Produce() override { return value_; } 
 
    private:
     const T value_;
@@ -346,7 +346,7 @@ class DefaultValue {
    public:
     explicit FactoryValueProducer(FactoryFunction factory)
         : factory_(factory) {}
-    T Produce() override { return factory_(); }
+    T Produce() override { return factory_(); } 
 
    private:
     const FactoryFunction factory_;
@@ -367,10 +367,10 @@ class DefaultValue<T&> {
   }
 
   // Unsets the default value for type T&.
-  static void Clear() { address_ = nullptr; }
+  static void Clear() { address_ = nullptr; } 
 
-  // Returns true if and only if the user has set the default value for type T&.
-  static bool IsSet() { return address_ != nullptr; }
+  // Returns true if and only if the user has set the default value for type T&. 
+  static bool IsSet() { return address_ != nullptr; } 
 
   // Returns true if T has a default return value set by the user or there
   // exists a built-in default value.
@@ -382,8 +382,8 @@ class DefaultValue<T&> {
   // otherwise returns the built-in default value if there is one;
   // otherwise aborts the process.
   static T& Get() {
-    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
-                               : *address_;
+    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get() 
+                               : *address_; 
   }
 
  private:
@@ -401,11 +401,11 @@ class DefaultValue<void> {
 
 // Points to the user-set default value for type T.
 template <typename T>
-typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr; 
 
 // Points to the user-set default value for type T&.
 template <typename T>
-T* DefaultValue<T&>::address_ = nullptr;
+T* DefaultValue<T&>::address_ = nullptr; 
 
 // Implement this interface to define an action for function type F.
 template <typename F>
@@ -430,60 +430,60 @@ class ActionInterface {
 // An Action<F> is a copyable and IMMUTABLE (except by assignment)
 // object that represents an action to be taken when a mock function
 // of type F is called.  The implementation of Action<T> is just a
-// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
+// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action! 
 // You can view an object implementing ActionInterface<F> as a
 // concrete action (including its current state), and an Action<F>
 // object as a handle to it.
 template <typename F>
 class Action {
-  // Adapter class to allow constructing Action from a legacy ActionInterface.
-  // New code should create Actions from functors instead.
-  struct ActionAdapter {
-    // Adapter must be copyable to satisfy std::function requirements.
-    ::std::shared_ptr<ActionInterface<F>> impl_;
-
-    template <typename... Args>
-    typename internal::Function<F>::Result operator()(Args&&... args) {
-      return impl_->Perform(
-          ::std::forward_as_tuple(::std::forward<Args>(args)...));
-    }
-  };
-
-  template <typename G>
-  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
-
+  // Adapter class to allow constructing Action from a legacy ActionInterface. 
+  // New code should create Actions from functors instead. 
+  struct ActionAdapter { 
+    // Adapter must be copyable to satisfy std::function requirements. 
+    ::std::shared_ptr<ActionInterface<F>> impl_; 
+ 
+    template <typename... Args> 
+    typename internal::Function<F>::Result operator()(Args&&... args) { 
+      return impl_->Perform( 
+          ::std::forward_as_tuple(::std::forward<Args>(args)...)); 
+    } 
+  }; 
+ 
+  template <typename G> 
+  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>; 
+ 
  public:
   typedef typename internal::Function<F>::Result Result;
   typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
 
   // Constructs a null Action.  Needed for storing Action objects in
   // STL containers.
-  Action() {}
-
-  // Construct an Action from a specified callable.
-  // This cannot take std::function directly, because then Action would not be
-  // directly constructible from lambda (it would require two conversions).
-  template <
-      typename G,
-      typename = typename std::enable_if<internal::disjunction<
-          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
-                                                        G>>::value>::type>
-  Action(G&& fun) {  // NOLINT
-    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
-  }
-
-  // Constructs an Action from its implementation.
-  explicit Action(ActionInterface<F>* impl)
-      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
+  Action() {} 
+
+  // Construct an Action from a specified callable. 
+  // This cannot take std::function directly, because then Action would not be 
+  // directly constructible from lambda (it would require two conversions). 
+  template < 
+      typename G, 
+      typename = typename std::enable_if<internal::disjunction< 
+          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>, 
+                                                        G>>::value>::type> 
+  Action(G&& fun) {  // NOLINT 
+    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>()); 
+  } 
+
+  // Constructs an Action from its implementation. 
+  explicit Action(ActionInterface<F>* impl) 
+      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {} 
 
   // This constructor allows us to turn an Action<Func> object into an
   // Action<F>, as long as F's arguments can be implicitly converted
-  // to Func's and Func's return type can be implicitly converted to F's.
+  // to Func's and Func's return type can be implicitly converted to F's. 
   template <typename Func>
-  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
+  explicit Action(const Action<Func>& action) : fun_(action.fun_) {} 
 
-  // Returns true if and only if this is the DoDefault() action.
-  bool IsDoDefault() const { return fun_ == nullptr; }
+  // Returns true if and only if this is the DoDefault() action. 
+  bool IsDoDefault() const { return fun_ == nullptr; } 
 
   // Performs the action.  Note that this method is const even though
   // the corresponding method in ActionInterface is not.  The reason
@@ -491,39 +491,39 @@ class Action {
   // another concrete action, not that the concrete action it binds to
   // cannot change state.  (Think of the difference between a const
   // pointer and a pointer to const.)
-  Result Perform(ArgumentTuple args) const {
-    if (IsDoDefault()) {
-      internal::IllegalDoDefault(__FILE__, __LINE__);
-    }
-    return internal::Apply(fun_, ::std::move(args));
+  Result Perform(ArgumentTuple args) const { 
+    if (IsDoDefault()) { 
+      internal::IllegalDoDefault(__FILE__, __LINE__); 
+    } 
+    return internal::Apply(fun_, ::std::move(args)); 
   }
 
  private:
-  template <typename G>
-  friend class Action;
-
-  template <typename G>
-  void Init(G&& g, ::std::true_type) {
-    fun_ = ::std::forward<G>(g);
-  }
-
-  template <typename G>
-  void Init(G&& g, ::std::false_type) {
-    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
-  }
-
-  template <typename FunctionImpl>
-  struct IgnoreArgs {
-    template <typename... Args>
-    Result operator()(const Args&...) const {
-      return function_impl();
-    }
-
-    FunctionImpl function_impl;
-  };
-
-  // fun_ is an empty function if and only if this is the DoDefault() action.
-  ::std::function<F> fun_;
+  template <typename G> 
+  friend class Action; 
+
+  template <typename G> 
+  void Init(G&& g, ::std::true_type) { 
+    fun_ = ::std::forward<G>(g); 
+  } 
+ 
+  template <typename G> 
+  void Init(G&& g, ::std::false_type) { 
+    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)}; 
+  } 
+ 
+  template <typename FunctionImpl> 
+  struct IgnoreArgs { 
+    template <typename... Args> 
+    Result operator()(const Args&...) const { 
+      return function_impl(); 
+    } 
+ 
+    FunctionImpl function_impl; 
+  }; 
+ 
+  // fun_ is an empty function if and only if this is the DoDefault() action. 
+  ::std::function<F> fun_; 
 };
 
 // The PolymorphicAction class template makes it easy to implement a
@@ -538,7 +538,7 @@ class Action {
 //     template <typename Result, typename ArgumentTuple>
 //     Result Perform(const ArgumentTuple& args) const {
 //       // Processes the arguments and returns a result, using
-//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple. 
 //     }
 //     ...
 //   };
@@ -566,7 +566,7 @@ class PolymorphicAction {
 
     explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
 
-    Result Perform(const ArgumentTuple& args) override {
+    Result Perform(const ArgumentTuple& args) override { 
       return impl_.template Perform<Result>(args);
     }
 
@@ -602,7 +602,7 @@ namespace internal {
 // on return. Useful for move-only types, but could be used on any type.
 template <typename T>
 struct ByMoveWrapper {
-  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
+  explicit ByMoveWrapper(T value) : payload(std::move(value)) {} 
   T payload;
 };
 
@@ -630,21 +630,21 @@ struct ByMoveWrapper {
 // statement, and conversion of the result of Return to Action<T(U)> is a
 // good place for that.
 //
-// The real life example of the above scenario happens when an invocation
-// of gtl::Container() is passed into Return.
-//
+// The real life example of the above scenario happens when an invocation 
+// of gtl::Container() is passed into Return. 
+// 
 template <typename R>
 class ReturnAction {
  public:
   // Constructs a ReturnAction object from the value to be returned.
   // 'value' is passed by value instead of by const reference in order
   // to allow Return("string literal") to compile.
-  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
+  explicit ReturnAction(R value) : value_(new R(std::move(value))) {} 
 
   // This template type conversion operator allows Return(x) to be
   // used in ANY function that returns x's type.
   template <typename F>
-  operator Action<F>() const {  // NOLINT
+  operator Action<F>() const {  // NOLINT 
     // Assert statement belongs here because this is the best place to verify
     // conditions on F. It produces the clearest error messages
     // in most compilers.
@@ -655,10 +655,10 @@ class ReturnAction {
     // in the Impl class. But both definitions must be the same.
     typedef typename Function<F>::Result Result;
     GTEST_COMPILE_ASSERT_(
-        !std::is_reference<Result>::value,
+        !std::is_reference<Result>::value, 
         use_ReturnRef_instead_of_Return_to_return_a_reference);
-    static_assert(!std::is_void<Result>::value,
-                  "Can't use Return() on an action expected to return `void`.");
+    static_assert(!std::is_void<Result>::value, 
+                  "Can't use Return() on an action expected to return `void`."); 
     return Action<F>(new Impl<R, F>(value_));
   }
 
@@ -677,14 +677,14 @@ class ReturnAction {
     // Result to call.  ImplicitCast_ forces the compiler to convert R to
     // Result without considering explicit constructors, thus resolving the
     // ambiguity. value_ is then initialized using its copy constructor.
-    explicit Impl(const std::shared_ptr<R>& value)
+    explicit Impl(const std::shared_ptr<R>& value) 
         : value_before_cast_(*value),
           value_(ImplicitCast_<Result>(value_before_cast_)) {}
 
-    Result Perform(const ArgumentTuple&) override { return value_; }
+    Result Perform(const ArgumentTuple&) override { return value_; } 
 
    private:
-    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
+    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value, 
                           Result_cannot_be_a_reference_type);
     // We save the value before casting just in case it is being cast to a
     // wrapper type.
@@ -702,22 +702,22 @@ class ReturnAction {
     typedef typename Function<F>::Result Result;
     typedef typename Function<F>::ArgumentTuple ArgumentTuple;
 
-    explicit Impl(const std::shared_ptr<R>& wrapper)
+    explicit Impl(const std::shared_ptr<R>& wrapper) 
         : performed_(false), wrapper_(wrapper) {}
 
-    Result Perform(const ArgumentTuple&) override {
+    Result Perform(const ArgumentTuple&) override { 
       GTEST_CHECK_(!performed_)
           << "A ByMove() action should only be performed once.";
       performed_ = true;
-      return std::move(wrapper_->payload);
+      return std::move(wrapper_->payload); 
     }
 
    private:
     bool performed_;
-    const std::shared_ptr<R> wrapper_;
+    const std::shared_ptr<R> wrapper_; 
   };
 
-  const std::shared_ptr<R> value_;
+  const std::shared_ptr<R> value_; 
 };
 
 // Implements the ReturnNull() action.
@@ -738,7 +738,7 @@ class ReturnVoidAction {
   // Allows Return() to be used in any void-returning function.
   template <typename Result, typename ArgumentTuple>
   static void Perform(const ArgumentTuple&) {
-    static_assert(std::is_void<Result>::value, "Result should be void.");
+    static_assert(std::is_void<Result>::value, "Result should be void."); 
   }
 };
 
@@ -759,7 +759,7 @@ class ReturnRefAction {
     // Asserts that the function return type is a reference.  This
     // catches the user error of using ReturnRef(x) when Return(x)
     // should be used, and generates some helpful error message.
-    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
+    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value, 
                           use_Return_instead_of_ReturnRef_to_return_a_value);
     return Action<F>(new Impl<F>(ref_));
   }
@@ -774,7 +774,7 @@ class ReturnRefAction {
 
     explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
 
-    Result Perform(const ArgumentTuple&) override { return ref_; }
+    Result Perform(const ArgumentTuple&) override { return ref_; } 
 
    private:
     T& ref_;
@@ -802,7 +802,7 @@ class ReturnRefOfCopyAction {
     // catches the user error of using ReturnRefOfCopy(x) when Return(x)
     // should be used, and generates some helpful error message.
     GTEST_COMPILE_ASSERT_(
-        std::is_reference<Result>::value,
+        std::is_reference<Result>::value, 
         use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
     return Action<F>(new Impl<F>(value_));
   }
@@ -817,43 +817,43 @@ class ReturnRefOfCopyAction {
 
     explicit Impl(const T& value) : value_(value) {}  // NOLINT
 
-    Result Perform(const ArgumentTuple&) override { return value_; }
+    Result Perform(const ArgumentTuple&) override { return value_; } 
 
    private:
     T value_;
   };
 
   const T value_;
-};
-
-// Implements the polymorphic ReturnRoundRobin(v) action, which can be
-// used in any function that returns the element_type of v.
-template <typename T>
-class ReturnRoundRobinAction {
- public:
-  explicit ReturnRoundRobinAction(std::vector<T> values) {
-    GTEST_CHECK_(!values.empty())
-        << "ReturnRoundRobin requires at least one element.";
-    state_->values = std::move(values);
-  }
-
-  template <typename... Args>
-  T operator()(Args&&...) const {
-     return state_->Next();
-  }
-
- private:
-  struct State {
-    T Next() {
-      T ret_val = values[i++];
-      if (i == values.size()) i = 0;
-      return ret_val;
-    }
-
-    std::vector<T> values;
-    size_t i = 0;
-  };
-  std::shared_ptr<State> state_ = std::make_shared<State>();
+}; 
+
+// Implements the polymorphic ReturnRoundRobin(v) action, which can be 
+// used in any function that returns the element_type of v. 
+template <typename T> 
+class ReturnRoundRobinAction { 
+ public: 
+  explicit ReturnRoundRobinAction(std::vector<T> values) { 
+    GTEST_CHECK_(!values.empty()) 
+        << "ReturnRoundRobin requires at least one element."; 
+    state_->values = std::move(values); 
+  } 
+ 
+  template <typename... Args> 
+  T operator()(Args&&...) const { 
+     return state_->Next(); 
+  } 
+ 
+ private: 
+  struct State { 
+    T Next() { 
+      T ret_val = values[i++]; 
+      if (i == values.size()) i = 0; 
+      return ret_val; 
+    } 
+ 
+    std::vector<T> values; 
+    size_t i = 0; 
+  }; 
+  std::shared_ptr<State> state_ = std::make_shared<State>(); 
 };
 
 // Implements the polymorphic DoDefault() action.
@@ -862,7 +862,7 @@ class DoDefaultAction {
   // This template type conversion operator allows DoDefault() to be
   // used in any function.
   template <typename F>
-  operator Action<F>() const { return Action<F>(); }  // NOLINT
+  operator Action<F>() const { return Action<F>(); }  // NOLINT 
 };
 
 // Implements the Assign action to set a given pointer referent to a
@@ -906,58 +906,58 @@ class SetErrnoAndReturnAction {
 #endif  // !GTEST_OS_WINDOWS_MOBILE
 
 // Implements the SetArgumentPointee<N>(x) action for any function
-// whose N-th argument (0-based) is a pointer to x's type.
-template <size_t N, typename A, typename = void>
-struct SetArgumentPointeeAction {
-  A value;
-
-  template <typename... Args>
-  void operator()(const Args&... args) const {
-    *::std::get<N>(std::tie(args...)) = value;
+// whose N-th argument (0-based) is a pointer to x's type. 
+template <size_t N, typename A, typename = void> 
+struct SetArgumentPointeeAction { 
+  A value; 
+
+  template <typename... Args> 
+  void operator()(const Args&... args) const { 
+    *::std::get<N>(std::tie(args...)) = value; 
   }
 };
 
-// Implements the Invoke(object_ptr, &Class::Method) action.
-template <class Class, typename MethodPtr>
-struct InvokeMethodAction {
-  Class* const obj_ptr;
-  const MethodPtr method_ptr;
-
-  template <typename... Args>
-  auto operator()(Args&&... args) const
-      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
-    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
+// Implements the Invoke(object_ptr, &Class::Method) action. 
+template <class Class, typename MethodPtr> 
+struct InvokeMethodAction { 
+  Class* const obj_ptr; 
+  const MethodPtr method_ptr; 
+
+  template <typename... Args> 
+  auto operator()(Args&&... args) const 
+      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) { 
+    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...); 
   }
 };
 
 // Implements the InvokeWithoutArgs(f) action.  The template argument
 // FunctionImpl is the implementation type of f, which can be either a
 // function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
-// Action<F> as long as f's type is compatible with F.
+// Action<F> as long as f's type is compatible with F. 
 template <typename FunctionImpl>
-struct InvokeWithoutArgsAction {
-  FunctionImpl function_impl;
+struct InvokeWithoutArgsAction { 
+  FunctionImpl function_impl; 
 
   // Allows InvokeWithoutArgs(f) to be used as any action whose type is
   // compatible with f.
-  template <typename... Args>
-  auto operator()(const Args&...) -> decltype(function_impl()) {
-    return function_impl();
-  }
+  template <typename... Args> 
+  auto operator()(const Args&...) -> decltype(function_impl()) { 
+    return function_impl(); 
+  } 
 };
 
 // Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
 template <class Class, typename MethodPtr>
-struct InvokeMethodWithoutArgsAction {
-  Class* const obj_ptr;
-  const MethodPtr method_ptr;
-
-  using ReturnType =
-      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
-
-  template <typename... Args>
-  ReturnType operator()(const Args&...) const {
-    return (obj_ptr->*method_ptr)();
+struct InvokeMethodWithoutArgsAction { 
+  Class* const obj_ptr; 
+  const MethodPtr method_ptr; 
+
+  using ReturnType = 
+      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())()); 
+ 
+  template <typename... Args> 
+  ReturnType operator()(const Args&...) const { 
+    return (obj_ptr->*method_ptr)(); 
   }
 };
 
@@ -980,7 +980,7 @@ class IgnoreResultAction {
     typedef typename internal::Function<F>::Result Result;
 
     // Asserts at compile time that F returns void.
-    static_assert(std::is_void<Result>::value, "Result type should be void.");
+    static_assert(std::is_void<Result>::value, "Result type should be void."); 
 
     return Action<F>(new Impl<F>(action_));
   }
@@ -994,7 +994,7 @@ class IgnoreResultAction {
 
     explicit Impl(const A& action) : action_(action) {}
 
-    void Perform(const ArgumentTuple& args) override {
+    void Perform(const ArgumentTuple& args) override { 
       // Performs the action and ignores its result.
       action_.Perform(args);
     }
@@ -1011,158 +1011,158 @@ class IgnoreResultAction {
   const A action_;
 };
 
-template <typename InnerAction, size_t... I>
-struct WithArgsAction {
-  InnerAction action;
-
-  // The inner action could be anything convertible to Action<X>.
-  // We use the conversion operator to detect the signature of the inner Action.
-  template <typename R, typename... Args>
-  operator Action<R(Args...)>() const {  // NOLINT
-    using TupleType = std::tuple<Args...>;
-    Action<R(typename std::tuple_element<I, TupleType>::type...)>
-        converted(action);
-
-    return [converted](Args... args) -> R {
-      return converted.Perform(std::forward_as_tuple(
-        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
-    };
-  }
+template <typename InnerAction, size_t... I> 
+struct WithArgsAction { 
+  InnerAction action; 
+
+  // The inner action could be anything convertible to Action<X>. 
+  // We use the conversion operator to detect the signature of the inner Action. 
+  template <typename R, typename... Args> 
+  operator Action<R(Args...)>() const {  // NOLINT 
+    using TupleType = std::tuple<Args...>; 
+    Action<R(typename std::tuple_element<I, TupleType>::type...)> 
+        converted(action); 
+ 
+    return [converted](Args... args) -> R { 
+      return converted.Perform(std::forward_as_tuple( 
+        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...)); 
+    }; 
+  } 
 };
 
-template <typename... Actions>
-struct DoAllAction {
- private:
-  template <typename T>
-  using NonFinalType =
-      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
-
-  template <typename ActionT, size_t... I>
-  std::vector<ActionT> Convert(IndexSequence<I...>) const {
-    return {ActionT(std::get<I>(actions))...};
-  }
+template <typename... Actions> 
+struct DoAllAction { 
+ private: 
+  template <typename T> 
+  using NonFinalType = 
+      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type; 
+ 
+  template <typename ActionT, size_t... I> 
+  std::vector<ActionT> Convert(IndexSequence<I...>) const { 
+    return {ActionT(std::get<I>(actions))...}; 
+  } 
 
  public:
-  std::tuple<Actions...> actions;
-
-  template <typename R, typename... Args>
-  operator Action<R(Args...)>() const {  // NOLINT
-    struct Op {
-      std::vector<Action<void(NonFinalType<Args>...)>> converted;
-      Action<R(Args...)> last;
-      R operator()(Args... args) const {
-        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
-        for (auto& a : converted) {
-          a.Perform(tuple_args);
-        }
-        return last.Perform(std::move(tuple_args));
-      }
-    };
-    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
-                  MakeIndexSequence<sizeof...(Actions) - 1>()),
-              std::get<sizeof...(Actions) - 1>(actions)};
-  }
-};
-
-template <typename T, typename... Params>
-struct ReturnNewAction {
-  T* operator()() const {
-    return internal::Apply(
-        [](const Params&... unpacked_params) {
-          return new T(unpacked_params...);
-        },
-        params);
-  }
-  std::tuple<Params...> params;
-};
-
-template <size_t k>
-struct ReturnArgAction {
-  template <typename... Args>
-  auto operator()(const Args&... args) const ->
-      typename std::tuple_element<k, std::tuple<Args...>>::type {
-    return std::get<k>(std::tie(args...));
-  }
-};
-
-template <size_t k, typename Ptr>
-struct SaveArgAction {
-  Ptr pointer;
-
-  template <typename... Args>
-  void operator()(const Args&... args) const {
-    *pointer = std::get<k>(std::tie(args...));
-  }
-};
-
-template <size_t k, typename Ptr>
-struct SaveArgPointeeAction {
-  Ptr pointer;
-
-  template <typename... Args>
-  void operator()(const Args&... args) const {
-    *pointer = *std::get<k>(std::tie(args...));
+  std::tuple<Actions...> actions; 
+
+  template <typename R, typename... Args> 
+  operator Action<R(Args...)>() const {  // NOLINT 
+    struct Op { 
+      std::vector<Action<void(NonFinalType<Args>...)>> converted; 
+      Action<R(Args...)> last; 
+      R operator()(Args... args) const { 
+        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...); 
+        for (auto& a : converted) { 
+          a.Perform(tuple_args); 
+        } 
+        return last.Perform(std::move(tuple_args)); 
+      } 
+    }; 
+    return Op{Convert<Action<void(NonFinalType<Args>...)>>( 
+                  MakeIndexSequence<sizeof...(Actions) - 1>()), 
+              std::get<sizeof...(Actions) - 1>(actions)}; 
   }
 };
 
-template <size_t k, typename T>
-struct SetArgRefereeAction {
-  T value;
-
-  template <typename... Args>
-  void operator()(Args&&... args) const {
-    using argk_type =
-        typename ::std::tuple_element<k, std::tuple<Args...>>::type;
-    static_assert(std::is_lvalue_reference<argk_type>::value,
-                  "Argument must be a reference type.");
-    std::get<k>(std::tie(args...)) = value;
-  }
-};
-
-template <size_t k, typename I1, typename I2>
-struct SetArrayArgumentAction {
-  I1 first;
-  I2 last;
-
-  template <typename... Args>
-  void operator()(const Args&... args) const {
-    auto value = std::get<k>(std::tie(args...));
-    for (auto it = first; it != last; ++it, (void)++value) {
-      *value = *it;
-    }
-  }
-};
-
-template <size_t k>
-struct DeleteArgAction {
-  template <typename... Args>
-  void operator()(const Args&... args) const {
-    delete std::get<k>(std::tie(args...));
-  }
-};
-
-template <typename Ptr>
-struct ReturnPointeeAction {
-  Ptr pointer;
-  template <typename... Args>
-  auto operator()(const Args&...) const -> decltype(*pointer) {
-    return *pointer;
-  }
-};
-
-#if GTEST_HAS_EXCEPTIONS
-template <typename T>
-struct ThrowAction {
-  T exception;
-  // We use a conversion operator to adapt to any return type.
-  template <typename R, typename... Args>
-  operator Action<R(Args...)>() const {  // NOLINT
-    T copy = exception;
-    return [copy](Args...) -> R { throw copy; };
-  }
-};
-#endif  // GTEST_HAS_EXCEPTIONS
-
+template <typename T, typename... Params> 
+struct ReturnNewAction { 
+  T* operator()() const { 
+    return internal::Apply( 
+        [](const Params&... unpacked_params) { 
+          return new T(unpacked_params...); 
+        }, 
+        params); 
+  } 
+  std::tuple<Params...> params; 
+}; 
+ 
+template <size_t k> 
+struct ReturnArgAction { 
+  template <typename... Args> 
+  auto operator()(const Args&... args) const -> 
+      typename std::tuple_element<k, std::tuple<Args...>>::type { 
+    return std::get<k>(std::tie(args...)); 
+  } 
+}; 
+ 
+template <size_t k, typename Ptr> 
+struct SaveArgAction { 
+  Ptr pointer; 
+ 
+  template <typename... Args> 
+  void operator()(const Args&... args) const { 
+    *pointer = std::get<k>(std::tie(args...)); 
+  } 
+}; 
+ 
+template <size_t k, typename Ptr> 
+struct SaveArgPointeeAction { 
+  Ptr pointer; 
+ 
+  template <typename... Args> 
+  void operator()(const Args&... args) const { 
+    *pointer = *std::get<k>(std::tie(args...)); 
+  } 
+}; 
+ 
+template <size_t k, typename T> 
+struct SetArgRefereeAction { 
+  T value; 
+ 
+  template <typename... Args> 
+  void operator()(Args&&... args) const { 
+    using argk_type = 
+        typename ::std::tuple_element<k, std::tuple<Args...>>::type; 
+    static_assert(std::is_lvalue_reference<argk_type>::value, 
+                  "Argument must be a reference type."); 
+    std::get<k>(std::tie(args...)) = value; 
+  } 
+}; 
+ 
+template <size_t k, typename I1, typename I2> 
+struct SetArrayArgumentAction { 
+  I1 first; 
+  I2 last; 
+ 
+  template <typename... Args> 
+  void operator()(const Args&... args) const { 
+    auto value = std::get<k>(std::tie(args...)); 
+    for (auto it = first; it != last; ++it, (void)++value) { 
+      *value = *it; 
+    } 
+  } 
+}; 
+ 
+template <size_t k> 
+struct DeleteArgAction { 
+  template <typename... Args> 
+  void operator()(const Args&... args) const { 
+    delete std::get<k>(std::tie(args...)); 
+  } 
+}; 
+ 
+template <typename Ptr> 
+struct ReturnPointeeAction { 
+  Ptr pointer; 
+  template <typename... Args> 
+  auto operator()(const Args&...) const -> decltype(*pointer) { 
+    return *pointer; 
+  } 
+}; 
+ 
+#if GTEST_HAS_EXCEPTIONS 
+template <typename T> 
+struct ThrowAction { 
+  T exception; 
+  // We use a conversion operator to adapt to any return type. 
+  template <typename R, typename... Args> 
+  operator Action<R(Args...)>() const {  // NOLINT 
+    T copy = exception; 
+    return [copy](Args...) -> R { throw copy; }; 
+  } 
+}; 
+#endif  // GTEST_HAS_EXCEPTIONS 
+ 
 }  // namespace internal
 
 // An Unused object can be implicitly constructed from ANY value.
@@ -1181,9 +1181,9 @@ struct ThrowAction {
 //     return sqrt(x*x + y*y);
 //   }
 //   ...
-//   EXPECT_CALL(mock, Foo("abc", _, _))
+//   EXPECT_CALL(mock, Foo("abc", _, _)) 
 //       .WillOnce(Invoke(DistanceToOriginWithLabel));
-//   EXPECT_CALL(mock, Bar(5, _, _))
+//   EXPECT_CALL(mock, Bar(5, _, _)) 
 //       .WillOnce(Invoke(DistanceToOriginWithIndex));
 //
 // you could write
@@ -1193,56 +1193,56 @@ struct ThrowAction {
 //     return sqrt(x*x + y*y);
 //   }
 //   ...
-//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
-//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); 
+//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); 
 typedef internal::IgnoredValue Unused;
 
-// Creates an action that does actions a1, a2, ..., sequentially in
-// each invocation. All but the last action will have a readonly view of the
-// arguments.
-template <typename... Action>
-internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
-    Action&&... action) {
-  return {std::forward_as_tuple(std::forward<Action>(action)...)};
-}
-
-// WithArg<k>(an_action) creates an action that passes the k-th
-// (0-based) argument of the mock function to an_action and performs
-// it.  It adapts an action accepting one argument to one that accepts
-// multiple arguments.  For convenience, we also provide
-// WithArgs<k>(an_action) (defined below) as a synonym.
-template <size_t k, typename InnerAction>
-internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
-WithArg(InnerAction&& action) {
-  return {std::forward<InnerAction>(action)};
-}
-
-// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
-// the selected arguments of the mock function to an_action and
-// performs it.  It serves as an adaptor between actions with
-// different argument lists.
-template <size_t k, size_t... ks, typename InnerAction>
-internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
-WithArgs(InnerAction&& action) {
-  return {std::forward<InnerAction>(action)};
-}
-
-// WithoutArgs(inner_action) can be used in a mock function with a
-// non-empty argument list to perform inner_action, which takes no
-// argument.  In other words, it adapts an action accepting no
-// argument to one that accepts (and ignores) arguments.
-template <typename InnerAction>
-internal::WithArgsAction<typename std::decay<InnerAction>::type>
-WithoutArgs(InnerAction&& action) {
-  return {std::forward<InnerAction>(action)};
-}
-
+// Creates an action that does actions a1, a2, ..., sequentially in 
+// each invocation. All but the last action will have a readonly view of the 
+// arguments. 
+template <typename... Action> 
+internal::DoAllAction<typename std::decay<Action>::type...> DoAll( 
+    Action&&... action) { 
+  return {std::forward_as_tuple(std::forward<Action>(action)...)}; 
+} 
+
+// WithArg<k>(an_action) creates an action that passes the k-th 
+// (0-based) argument of the mock function to an_action and performs 
+// it.  It adapts an action accepting one argument to one that accepts 
+// multiple arguments.  For convenience, we also provide 
+// WithArgs<k>(an_action) (defined below) as a synonym. 
+template <size_t k, typename InnerAction> 
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k> 
+WithArg(InnerAction&& action) { 
+  return {std::forward<InnerAction>(action)}; 
+} 
+ 
+// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes 
+// the selected arguments of the mock function to an_action and 
+// performs it.  It serves as an adaptor between actions with 
+// different argument lists. 
+template <size_t k, size_t... ks, typename InnerAction> 
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...> 
+WithArgs(InnerAction&& action) { 
+  return {std::forward<InnerAction>(action)}; 
+} 
+ 
+// WithoutArgs(inner_action) can be used in a mock function with a 
+// non-empty argument list to perform inner_action, which takes no 
+// argument.  In other words, it adapts an action accepting no 
+// argument to one that accepts (and ignores) arguments. 
+template <typename InnerAction> 
+internal::WithArgsAction<typename std::decay<InnerAction>::type> 
+WithoutArgs(InnerAction&& action) { 
+  return {std::forward<InnerAction>(action)}; 
+} 
+ 
 // Creates an action that returns 'value'.  'value' is passed by value
 // instead of const reference - otherwise Return("string literal")
 // will trigger a compiler error about using array as initializer.
 template <typename R>
 internal::ReturnAction<R> Return(R value) {
-  return internal::ReturnAction<R>(std::move(value));
+  return internal::ReturnAction<R>(std::move(value)); 
 }
 
 // Creates an action that returns NULL.
@@ -1261,10 +1261,10 @@ inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
   return internal::ReturnRefAction<R>(x);
 }
 
-// Prevent using ReturnRef on reference to temporary.
-template <typename R, R* = nullptr>
-internal::ReturnRefAction<R> ReturnRef(R&&) = delete;
-
+// Prevent using ReturnRef on reference to temporary. 
+template <typename R, R* = nullptr> 
+internal::ReturnRefAction<R> ReturnRef(R&&) = delete; 
+ 
 // Creates an action that returns the reference to a copy of the
 // argument.  The copy is created when the action is constructed and
 // lives as long as the action.
@@ -1279,26 +1279,26 @@ inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
 // invariant.
 template <typename R>
 internal::ByMoveWrapper<R> ByMove(R x) {
-  return internal::ByMoveWrapper<R>(std::move(x));
-}
-
-// Creates an action that returns an element of `vals`. Calling this action will
-// repeatedly return the next value from `vals` until it reaches the end and
-// will restart from the beginning.
-template <typename T>
-internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
-  return internal::ReturnRoundRobinAction<T>(std::move(vals));
-}
-
-// Creates an action that returns an element of `vals`. Calling this action will
-// repeatedly return the next value from `vals` until it reaches the end and
-// will restart from the beginning.
-template <typename T>
-internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
-    std::initializer_list<T> vals) {
-  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
+  return internal::ByMoveWrapper<R>(std::move(x)); 
 }
 
+// Creates an action that returns an element of `vals`. Calling this action will 
+// repeatedly return the next value from `vals` until it reaches the end and 
+// will restart from the beginning. 
+template <typename T> 
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) { 
+  return internal::ReturnRoundRobinAction<T>(std::move(vals)); 
+} 
+ 
+// Creates an action that returns an element of `vals`. Calling this action will 
+// repeatedly return the next value from `vals` until it reaches the end and 
+// will restart from the beginning. 
+template <typename T> 
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin( 
+    std::initializer_list<T> vals) { 
+  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals)); 
+} 
+ 
 // Creates an action that does the default action for the give mock function.
 inline internal::DoDefaultAction DoDefault() {
   return internal::DoDefaultAction();
@@ -1307,14 +1307,14 @@ inline internal::DoDefaultAction DoDefault() {
 // Creates an action that sets the variable pointed by the N-th
 // (0-based) function argument to 'value'.
 template <size_t N, typename T>
-internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
-  return {std::move(value)};
+internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) { 
+  return {std::move(value)}; 
 }
 
 // The following version is DEPRECATED.
 template <size_t N, typename T>
-internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
-  return {std::move(value)};
+internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) { 
+  return {std::move(value)}; 
 }
 
 // Creates an action that sets a pointer referent to a given value.
@@ -1335,38 +1335,38 @@ SetErrnoAndReturn(int errval, T result) {
 
 #endif  // !GTEST_OS_WINDOWS_MOBILE
 
-// Various overloads for Invoke().
-
-// Legacy function.
-// Actions can now be implicitly constructed from callables. No need to create
-// wrapper objects.
-// This function exists for backwards compatibility.
-template <typename FunctionImpl>
-typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
-  return std::forward<FunctionImpl>(function_impl);
-}
-
-// Creates an action that invokes the given method on the given object
-// with the mock function's arguments.
-template <class Class, typename MethodPtr>
-internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
-                                                      MethodPtr method_ptr) {
-  return {obj_ptr, method_ptr};
-}
-
+// Various overloads for Invoke(). 
+
+// Legacy function. 
+// Actions can now be implicitly constructed from callables. No need to create 
+// wrapper objects. 
+// This function exists for backwards compatibility. 
+template <typename FunctionImpl> 
+typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) { 
+  return std::forward<FunctionImpl>(function_impl); 
+} 
+ 
+// Creates an action that invokes the given method on the given object 
+// with the mock function's arguments. 
+template <class Class, typename MethodPtr> 
+internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr, 
+                                                      MethodPtr method_ptr) { 
+  return {obj_ptr, method_ptr}; 
+} 
+ 
 // Creates an action that invokes 'function_impl' with no argument.
 template <typename FunctionImpl>
-internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
+internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type> 
 InvokeWithoutArgs(FunctionImpl function_impl) {
-  return {std::move(function_impl)};
+  return {std::move(function_impl)}; 
 }
 
 // Creates an action that invokes the given method on the given object
 // with no argument.
 template <class Class, typename MethodPtr>
-internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
-    Class* obj_ptr, MethodPtr method_ptr) {
-  return {obj_ptr, method_ptr};
+internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs( 
+    Class* obj_ptr, MethodPtr method_ptr) { 
+  return {obj_ptr, method_ptr}; 
 }
 
 // Creates an action that performs an_action and throws away its
@@ -1384,304 +1384,304 @@ inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
 // where Base is a base class of Derived, just write:
 //
 //   ByRef<const Base>(derived)
-//
-// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
-// However, it may still be used for consistency with ByMove().
+// 
+// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper. 
+// However, it may still be used for consistency with ByMove(). 
 template <typename T>
-inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
-  return ::std::reference_wrapper<T>(l_value);
+inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT 
+  return ::std::reference_wrapper<T>(l_value); 
 }
 
-// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
-// instance of type T, constructed on the heap with constructor arguments
-// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
-template <typename T, typename... Params>
-internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
-    Params&&... params) {
-  return {std::forward_as_tuple(std::forward<Params>(params)...)};
-}
-
-// Action ReturnArg<k>() returns the k-th argument of the mock function.
-template <size_t k>
-internal::ReturnArgAction<k> ReturnArg() {
-  return {};
-}
-
-// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
-// mock function to *pointer.
-template <size_t k, typename Ptr>
-internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
-  return {pointer};
-}
-
-// Action SaveArgPointee<k>(pointer) saves the value pointed to
-// by the k-th (0-based) argument of the mock function to *pointer.
-template <size_t k, typename Ptr>
-internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
-  return {pointer};
-}
-
-// Action SetArgReferee<k>(value) assigns 'value' to the variable
-// referenced by the k-th (0-based) argument of the mock function.
-template <size_t k, typename T>
-internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
-    T&& value) {
-  return {std::forward<T>(value)};
-}
-
-// Action SetArrayArgument<k>(first, last) copies the elements in
-// source range [first, last) to the array pointed to by the k-th
-// (0-based) argument, which can be either a pointer or an
-// iterator. The action does not take ownership of the elements in the
-// source range.
-template <size_t k, typename I1, typename I2>
-internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
-                                                             I2 last) {
-  return {first, last};
-}
-
-// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
-// function.
-template <size_t k>
-internal::DeleteArgAction<k> DeleteArg() {
-  return {};
-}
-
-// This action returns the value pointed to by 'pointer'.
-template <typename Ptr>
-internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
-  return {pointer};
-}
-
-// Action Throw(exception) can be used in a mock function of any type
-// to throw the given exception.  Any copyable value can be thrown.
-#if GTEST_HAS_EXCEPTIONS
-template <typename T>
-internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
-  return {std::forward<T>(exception)};
-}
-#endif  // GTEST_HAS_EXCEPTIONS
-
-namespace internal {
-
-// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
-// defines an action that can be used in a mock function.  Typically,
-// these actions only care about a subset of the arguments of the mock
-// function.  For example, if such an action only uses the second
-// argument, it can be used in any mock function that takes >= 2
-// arguments where the type of the second argument is compatible.
-//
-// Therefore, the action implementation must be prepared to take more
-// arguments than it needs.  The ExcessiveArg type is used to
-// represent those excessive arguments.  In order to keep the compiler
-// error messages tractable, we define it in the testing namespace
-// instead of testing::internal.  However, this is an INTERNAL TYPE
-// and subject to change without notice, so a user MUST NOT USE THIS
-// TYPE DIRECTLY.
-struct ExcessiveArg {};
-
-// Builds an implementation of an Action<> for some particular signature, using
-// a class defined by an ACTION* macro.
-template <typename F, typename Impl> struct ActionImpl;
-
-template <typename Impl>
-struct ImplBase {
-  struct Holder {
-    // Allows each copy of the Action<> to get to the Impl.
-    explicit operator const Impl&() const { return *ptr; }
-    std::shared_ptr<Impl> ptr;
-  };
-  using type = typename std::conditional<std::is_constructible<Impl>::value,
-                                         Impl, Holder>::type;
-};
-
-template <typename R, typename... Args, typename Impl>
-struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
-  using Base = typename ImplBase<Impl>::type;
-  using function_type = R(Args...);
-  using args_type = std::tuple<Args...>;
-
-  ActionImpl() = default;  // Only defined if appropriate for Base.
-  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }
-
-  R operator()(Args&&... arg) const {
-    static constexpr size_t kMaxArgs =
-        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
-    return Apply(MakeIndexSequence<kMaxArgs>{},
-                 MakeIndexSequence<10 - kMaxArgs>{},
-                 args_type{std::forward<Args>(arg)...});
-  }
-
-  template <std::size_t... arg_id, std::size_t... excess_id>
-  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
-          const args_type& args) const {
-    // Impl need not be specific to the signature of action being implemented;
-    // only the implementing function body needs to have all of the specific
-    // types instantiated.  Up to 10 of the args that are provided by the
-    // args_type get passed, followed by a dummy of unspecified type for the
-    // remainder up to 10 explicit args.
-    static constexpr ExcessiveArg kExcessArg{};
-    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
-        /*function_type=*/function_type, /*return_type=*/R,
-        /*args_type=*/args_type,
-        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
-        /*args=*/args, std::get<arg_id>(args)...,
-        ((void)excess_id, kExcessArg)...);
-  }
-};
-
-// Stores a default-constructed Impl as part of the Action<>'s
-// std::function<>. The Impl should be trivial to copy.
-template <typename F, typename Impl>
-::testing::Action<F> MakeAction() {
-  return ::testing::Action<F>(ActionImpl<F, Impl>());
-}
-
-// Stores just the one given instance of Impl.
-template <typename F, typename Impl>
-::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
-  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
-}
-
-#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
-  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \
-  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
-      GMOCK_INTERNAL_ARG_UNUSED, , 10)
-
-#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
-  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
-
-#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
-#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
-  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
-
-#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
-#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
-
-#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
-#define GMOCK_ACTION_TYPE_PARAMS_(params) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
-
-#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
-  , param##_type gmock_p##i
-#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
-
-#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
-  , std::forward<param##_type>(gmock_p##i)
-#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
-
-#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
-  , param(::std::forward<param##_type>(gmock_p##i))
-#define GMOCK_ACTION_INIT_PARAMS_(params) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
-
-#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
-#define GMOCK_ACTION_FIELD_PARAMS_(params) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
-
-#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  class full_name {                                                           \
-   public:                                                                    \
-    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
-        : impl_(std::make_shared<gmock_Impl>(                                 \
-                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
-    full_name(const full_name&) = default;                                    \
-    full_name(full_name&&) noexcept = default;                                \
-    template <typename F>                                                     \
-    operator ::testing::Action<F>() const {                                   \
-      return ::testing::internal::MakeAction<F>(impl_);                       \
-    }                                                                         \
-   private:                                                                   \
-    class gmock_Impl {                                                        \
-     public:                                                                  \
-      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
-          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
-      template <typename function_type, typename return_type,                 \
-                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
-      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
-      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
-    };                                                                        \
-    std::shared_ptr<const gmock_Impl> impl_;                                  \
-  };                                                                          \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
-      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
-    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
-        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
-  }                                                                           \
-  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
-  template <typename function_type, typename return_type, typename args_type, \
-            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
-  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
-  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-}  // namespace internal
-
-// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored.
-#define ACTION(name)                                                          \
-  class name##Action {                                                        \
-   public:                                                                    \
-   explicit name##Action() noexcept {}                                        \
-   name##Action(const name##Action&) noexcept {}                              \
-    template <typename F>                                                     \
-    operator ::testing::Action<F>() const {                                   \
-      return ::testing::internal::MakeAction<F, gmock_Impl>();                \
-    }                                                                         \
-   private:                                                                   \
-    class gmock_Impl {                                                        \
-     public:                                                                  \
-      template <typename function_type, typename return_type,                 \
-                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
-      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
-    };                                                                        \
-  };                                                                          \
-  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
-  inline name##Action name() { return name##Action(); }                       \
-  template <typename function_type, typename return_type, typename args_type, \
-            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
-  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \
-      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-#define ACTION_P(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
-
-#define ACTION_P2(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
-
-#define ACTION_P3(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
-
-#define ACTION_P4(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
-
-#define ACTION_P5(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
-
-#define ACTION_P6(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
-
-#define ACTION_P7(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
-
-#define ACTION_P8(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
-
-#define ACTION_P9(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
-
-#define ACTION_P10(name, ...) \
-  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
-
+// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new 
+// instance of type T, constructed on the heap with constructor arguments 
+// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. 
+template <typename T, typename... Params> 
+internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew( 
+    Params&&... params) { 
+  return {std::forward_as_tuple(std::forward<Params>(params)...)}; 
+} 
+ 
+// Action ReturnArg<k>() returns the k-th argument of the mock function. 
+template <size_t k> 
+internal::ReturnArgAction<k> ReturnArg() { 
+  return {}; 
+} 
+ 
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the 
+// mock function to *pointer. 
+template <size_t k, typename Ptr> 
+internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) { 
+  return {pointer}; 
+} 
+ 
+// Action SaveArgPointee<k>(pointer) saves the value pointed to 
+// by the k-th (0-based) argument of the mock function to *pointer. 
+template <size_t k, typename Ptr> 
+internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) { 
+  return {pointer}; 
+} 
+ 
+// Action SetArgReferee<k>(value) assigns 'value' to the variable 
+// referenced by the k-th (0-based) argument of the mock function. 
+template <size_t k, typename T> 
+internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee( 
+    T&& value) { 
+  return {std::forward<T>(value)}; 
+} 
+ 
+// Action SetArrayArgument<k>(first, last) copies the elements in 
+// source range [first, last) to the array pointed to by the k-th 
+// (0-based) argument, which can be either a pointer or an 
+// iterator. The action does not take ownership of the elements in the 
+// source range. 
+template <size_t k, typename I1, typename I2> 
+internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first, 
+                                                             I2 last) { 
+  return {first, last}; 
+} 
+ 
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock 
+// function. 
+template <size_t k> 
+internal::DeleteArgAction<k> DeleteArg() { 
+  return {}; 
+} 
+ 
+// This action returns the value pointed to by 'pointer'. 
+template <typename Ptr> 
+internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) { 
+  return {pointer}; 
+} 
+ 
+// Action Throw(exception) can be used in a mock function of any type 
+// to throw the given exception.  Any copyable value can be thrown. 
+#if GTEST_HAS_EXCEPTIONS 
+template <typename T> 
+internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) { 
+  return {std::forward<T>(exception)}; 
+} 
+#endif  // GTEST_HAS_EXCEPTIONS 
+ 
+namespace internal { 
+ 
+// A macro from the ACTION* family (defined later in gmock-generated-actions.h) 
+// defines an action that can be used in a mock function.  Typically, 
+// these actions only care about a subset of the arguments of the mock 
+// function.  For example, if such an action only uses the second 
+// argument, it can be used in any mock function that takes >= 2 
+// arguments where the type of the second argument is compatible. 
+// 
+// Therefore, the action implementation must be prepared to take more 
+// arguments than it needs.  The ExcessiveArg type is used to 
+// represent those excessive arguments.  In order to keep the compiler 
+// error messages tractable, we define it in the testing namespace 
+// instead of testing::internal.  However, this is an INTERNAL TYPE 
+// and subject to change without notice, so a user MUST NOT USE THIS 
+// TYPE DIRECTLY. 
+struct ExcessiveArg {}; 
+ 
+// Builds an implementation of an Action<> for some particular signature, using 
+// a class defined by an ACTION* macro. 
+template <typename F, typename Impl> struct ActionImpl; 
+ 
+template <typename Impl> 
+struct ImplBase { 
+  struct Holder { 
+    // Allows each copy of the Action<> to get to the Impl. 
+    explicit operator const Impl&() const { return *ptr; } 
+    std::shared_ptr<Impl> ptr; 
+  }; 
+  using type = typename std::conditional<std::is_constructible<Impl>::value, 
+                                         Impl, Holder>::type; 
+}; 
+ 
+template <typename R, typename... Args, typename Impl> 
+struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type { 
+  using Base = typename ImplBase<Impl>::type; 
+  using function_type = R(Args...); 
+  using args_type = std::tuple<Args...>; 
+ 
+  ActionImpl() = default;  // Only defined if appropriate for Base. 
+  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { } 
+ 
+  R operator()(Args&&... arg) const { 
+    static constexpr size_t kMaxArgs = 
+        sizeof...(Args) <= 10 ? sizeof...(Args) : 10; 
+    return Apply(MakeIndexSequence<kMaxArgs>{}, 
+                 MakeIndexSequence<10 - kMaxArgs>{}, 
+                 args_type{std::forward<Args>(arg)...}); 
+  } 
+ 
+  template <std::size_t... arg_id, std::size_t... excess_id> 
+  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>, 
+          const args_type& args) const { 
+    // Impl need not be specific to the signature of action being implemented; 
+    // only the implementing function body needs to have all of the specific 
+    // types instantiated.  Up to 10 of the args that are provided by the 
+    // args_type get passed, followed by a dummy of unspecified type for the 
+    // remainder up to 10 explicit args. 
+    static constexpr ExcessiveArg kExcessArg{}; 
+    return static_cast<const Impl&>(*this).template gmock_PerformImpl< 
+        /*function_type=*/function_type, /*return_type=*/R, 
+        /*args_type=*/args_type, 
+        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>( 
+        /*args=*/args, std::get<arg_id>(args)..., 
+        ((void)excess_id, kExcessArg)...); 
+  } 
+}; 
+ 
+// Stores a default-constructed Impl as part of the Action<>'s 
+// std::function<>. The Impl should be trivial to copy. 
+template <typename F, typename Impl> 
+::testing::Action<F> MakeAction() { 
+  return ::testing::Action<F>(ActionImpl<F, Impl>()); 
+} 
+ 
+// Stores just the one given instance of Impl. 
+template <typename F, typename Impl> 
+::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) { 
+  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl))); 
+} 
+ 
+#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ 
+  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ 
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \ 
+  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ 
+      GMOCK_INTERNAL_ARG_UNUSED, , 10) 
+ 
+#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i 
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ 
+  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) 
+ 
+#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type 
+#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ 
+  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) 
+ 
+#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type 
+#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) 
+ 
+#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type 
+#define GMOCK_ACTION_TYPE_PARAMS_(params) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) 
+ 
+#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ 
+  , param##_type gmock_p##i 
+#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) 
+ 
+#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ 
+  , std::forward<param##_type>(gmock_p##i) 
+#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) 
+ 
+#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ 
+  , param(::std::forward<param##_type>(gmock_p##i)) 
+#define GMOCK_ACTION_INIT_PARAMS_(params) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) 
+ 
+#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; 
+#define GMOCK_ACTION_FIELD_PARAMS_(params) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) 
+ 
+#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \ 
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \ 
+  class full_name {                                                           \ 
+   public:                                                                    \ 
+    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \ 
+        : impl_(std::make_shared<gmock_Impl>(                                 \ 
+                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \ 
+    full_name(const full_name&) = default;                                    \ 
+    full_name(full_name&&) noexcept = default;                                \ 
+    template <typename F>                                                     \ 
+    operator ::testing::Action<F>() const {                                   \ 
+      return ::testing::internal::MakeAction<F>(impl_);                       \ 
+    }                                                                         \ 
+   private:                                                                   \ 
+    class gmock_Impl {                                                        \ 
+     public:                                                                  \ 
+      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \ 
+          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \ 
+      template <typename function_type, typename return_type,                 \ 
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \ 
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ 
+      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \ 
+    };                                                                        \ 
+    std::shared_ptr<const gmock_Impl> impl_;                                  \ 
+  };                                                                          \ 
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \ 
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \ 
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \ 
+    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \ 
+        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \ 
+  }                                                                           \ 
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \ 
+  template <typename function_type, typename return_type, typename args_type, \ 
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \ 
+  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \ 
+  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 
+ 
+}  // namespace internal 
+ 
+// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. 
+#define ACTION(name)                                                          \ 
+  class name##Action {                                                        \ 
+   public:                                                                    \ 
+   explicit name##Action() noexcept {}                                        \ 
+   name##Action(const name##Action&) noexcept {}                              \ 
+    template <typename F>                                                     \ 
+    operator ::testing::Action<F>() const {                                   \ 
+      return ::testing::internal::MakeAction<F, gmock_Impl>();                \ 
+    }                                                                         \ 
+   private:                                                                   \ 
+    class gmock_Impl {                                                        \ 
+     public:                                                                  \ 
+      template <typename function_type, typename return_type,                 \ 
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \ 
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ 
+    };                                                                        \ 
+  };                                                                          \ 
+  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \ 
+  inline name##Action name() { return name##Action(); }                       \ 
+  template <typename function_type, typename return_type, typename args_type, \ 
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \ 
+  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \ 
+      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 
+ 
+#define ACTION_P(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) 
+ 
+#define ACTION_P2(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) 
+ 
+#define ACTION_P3(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) 
+ 
+#define ACTION_P4(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) 
+ 
+#define ACTION_P5(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) 
+ 
+#define ACTION_P6(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) 
+ 
+#define ACTION_P7(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) 
+ 
+#define ACTION_P8(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) 
+ 
+#define ACTION_P9(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) 
+ 
+#define ACTION_P10(name, ...) \ 
+  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) 
+ 
 }  // namespace testing
 
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#ifdef _MSC_VER 
+# pragma warning(pop) 
+#endif 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-cardinalities.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-cardinalities.h
index fc7f803a7a..12cc925411 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-cardinalities.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-cardinalities.h
@@ -27,27 +27,27 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements some commonly used cardinalities.  More
 // cardinalities can be defined by the user implementing the
 // CardinalityInterface interface if necessary.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ 
 
 #include <limits.h>
-#include <memory>
+#include <memory> 
 #include <ostream>  // NOLINT
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 
 // To implement a cardinality Foo, define:
@@ -70,12 +70,12 @@ class CardinalityInterface {
   virtual int ConservativeLowerBound() const { return 0; }
   virtual int ConservativeUpperBound() const { return INT_MAX; }
 
-  // Returns true if and only if call_count calls will satisfy this
-  // cardinality.
+  // Returns true if and only if call_count calls will satisfy this 
+  // cardinality. 
   virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
 
-  // Returns true if and only if call_count calls will saturate this
-  // cardinality.
+  // Returns true if and only if call_count calls will saturate this 
+  // cardinality. 
   virtual bool IsSaturatedByCallCount(int call_count) const = 0;
 
   // Describes self to an ostream.
@@ -84,8 +84,8 @@ class CardinalityInterface {
 
 // A Cardinality is a copyable and IMMUTABLE (except by assignment)
 // object that specifies how many times a mock function is expected to
-// be called.  The implementation of Cardinality is just a std::shared_ptr
-// to const CardinalityInterface. Don't inherit from Cardinality!
+// be called.  The implementation of Cardinality is just a std::shared_ptr 
+// to const CardinalityInterface. Don't inherit from Cardinality! 
 class GTEST_API_ Cardinality {
  public:
   // Constructs a null cardinality.  Needed for storing Cardinality
@@ -100,19 +100,19 @@ class GTEST_API_ Cardinality {
   int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
   int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
 
-  // Returns true if and only if call_count calls will satisfy this
-  // cardinality.
+  // Returns true if and only if call_count calls will satisfy this 
+  // cardinality. 
   bool IsSatisfiedByCallCount(int call_count) const {
     return impl_->IsSatisfiedByCallCount(call_count);
   }
 
-  // Returns true if and only if call_count calls will saturate this
-  // cardinality.
+  // Returns true if and only if call_count calls will saturate this 
+  // cardinality. 
   bool IsSaturatedByCallCount(int call_count) const {
     return impl_->IsSaturatedByCallCount(call_count);
   }
 
-  // Returns true if and only if call_count calls will over-saturate this
+  // Returns true if and only if call_count calls will over-saturate this 
   // cardinality, i.e. exceed the maximum number of allowed calls.
   bool IsOverSaturatedByCallCount(int call_count) const {
     return impl_->IsSaturatedByCallCount(call_count) &&
@@ -127,7 +127,7 @@ class GTEST_API_ Cardinality {
                                         ::std::ostream* os);
 
  private:
-  std::shared_ptr<const CardinalityInterface> impl_;
+  std::shared_ptr<const CardinalityInterface> impl_; 
 };
 
 // Creates a cardinality that allows at least n calls.
@@ -152,6 +152,6 @@ inline Cardinality MakeCardinality(const CardinalityInterface* c) {
 
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-function-mocker.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-function-mocker.h
index 0fc6f6f3f1..2fe1b20100 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-function-mocker.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-function-mocker.h
@@ -1,479 +1,479 @@
-// Copyright 2007, 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.
-
-// Google Mock - a framework for writing C++ mock classes.
-//
-// This file implements MOCK_METHOD.
-
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
-
-#include <type_traits>  // IWYU pragma: keep
-#include <utility>      // IWYU pragma: keep
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-internal-utils.h"
-#include "gmock/internal/gmock-pp.h"
-
-namespace testing {
-namespace internal {
-template <typename T>
-using identity_t = T;
-
-template <typename Pattern>
-struct ThisRefAdjuster {
-  template <typename T>
-  using AdjustT = typename std::conditional<
-      std::is_const<typename std::remove_reference<Pattern>::type>::value,
-      typename std::conditional<std::is_lvalue_reference<Pattern>::value,
-                                const T&, const T&&>::type,
-      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
-                                T&&>::type>::type;
-
-  template <typename MockType>
-  static AdjustT<MockType> Adjust(const MockType& mock) {
-    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
-  }
-};
-
-}  // namespace internal
-
-// The style guide prohibits "using" statements in a namespace scope
-// inside a header file.  However, the FunctionMocker class template
-// is meant to be defined in the ::testing namespace.  The following
-// line is just a trick for working around a bug in MSVC 8.0, which
-// cannot handle it if we define FunctionMocker in ::testing.
-using internal::FunctionMocker;
-}  // namespace testing
-
-#define MOCK_METHOD(...) \
-  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
-  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
-  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
-  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \
-  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \
-  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \
-  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \
-      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \
-  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \
-  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \
-      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \
-      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \
-      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \
-      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \
-      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
-  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
-  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
-  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
-
-#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
-  static_assert(                                                             \
-      false,                                                                 \
-      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
-      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
-      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
-      "it must also be enclosed in parentheses.")
-
-#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
-  static_assert(                                  \
-      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
-      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
-
-#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
-  static_assert(                                                       \
-      std::is_function<__VA_ARGS__>::value,                            \
-      "Signature must be a function type, maybe return type contains " \
-      "unprotected comma.");                                           \
-  static_assert(                                                       \
-      ::testing::tuple_size<typename ::testing::internal::Function<    \
-              __VA_ARGS__>::ArgumentTuple>::value == _N,               \
-      "This method does not take " GMOCK_PP_STRINGIZE(                 \
-          _N) " arguments. Parenthesize all types with unprotected commas.")
-
-#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
-
-#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
-                                        _Override, _Final, _NoexceptSpec,      \
-                                        _CallType, _RefSpec, _Signature)       \
-  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
-      _Signature)>::Result                                                     \
-  GMOCK_INTERNAL_EXPAND(_CallType)                                             \
-      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
-          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \
-          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \
-    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
-        .SetOwnerAndName(this, #_MethodName);                                  \
-    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
-        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
-  }                                                                            \
-  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
-      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
-      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
-    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
-    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
-        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
-  }                                                                            \
-  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
-      const ::testing::internal::WithoutMatchers&,                             \
-      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
-          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
-    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
-        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
-        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
-            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
-  }                                                                            \
-  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
-      GMOCK_MOCKER_(_N, _Constness, _MethodName)
-
-#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
-
-// Five Valid modifiers.
-#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
-  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
-
-#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
-  GMOCK_PP_HAS_COMMA(                       \
-      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
-
-#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
-  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))
-
-#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)
-
-#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
-  GMOCK_PP_IF(                                                          \
-      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
-      _elem, )
-
-#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
-
-#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
-  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
-              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
-
-#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)
-
-#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \
-  static_assert(                                                          \
-      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \
-       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \
-       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \
-      GMOCK_PP_STRINGIZE(                                                 \
-          _elem) " cannot be recognized as a valid specification modifier.");
-
-// Modifiers implementation.
-#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
-  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
-
-#define GMOCK_INTERNAL_DETECT_CONST_I_const ,
-
-#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
-  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
-
-#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
-
-#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
-  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
-
-#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
-
-#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
-  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
-
-#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
-
-#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
-  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)
-
-#define GMOCK_INTERNAL_DETECT_REF_I_ref ,
-
-#define GMOCK_INTERNAL_UNPACK_ref(x) x
-
-#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \
-  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \
-              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
-  (_elem)
-
-// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
-// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows
-// maybe they can be simplified somehow.
-#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
-  GMOCK_INTERNAL_IS_CALLTYPE_I(          \
-      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
-#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg)
-
-#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
-  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \
-      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
-#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
-  GMOCK_PP_IDENTITY _arg
-
-#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype
-
-// Note: The use of `identity_t` here allows _Ret to represent return types that
-// would normally need to be specified in a different way. For example, a method
-// returning a function pointer must be written as
-//
-// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
-//
-// But we only support placing the return type at the beginning. To handle this,
-// we wrap all calls in identity_t, so that a declaration will be expanded to
-//
-// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
-//
-// This allows us to work around the syntactic oddities of function/method
-// types.
-#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
-  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
-                                              GMOCK_PP_REMOVE_PARENS,         \
-                                              GMOCK_PP_IDENTITY)(_Ret)>(      \
-      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
-
-#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
-  GMOCK_PP_COMMA_IF(_i)                                                \
-  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
-              GMOCK_PP_IDENTITY)                                       \
-  (_elem)
-
-#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
-  GMOCK_PP_COMMA_IF(_i)                                        \
-  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
-  gmock_a##_i
-
-#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
-  GMOCK_PP_COMMA_IF(_i)                               \
-  ::std::forward<GMOCK_INTERNAL_ARG_O(                \
-      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)
-
-#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
-  GMOCK_PP_COMMA_IF(_i)                                            \
-  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
-  gmock_a##_i
-
-#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
-  GMOCK_PP_COMMA_IF(_i)                             \
-  gmock_a##_i
-
-#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
-  GMOCK_PP_COMMA_IF(_i)                                      \
-  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()
-
-#define GMOCK_INTERNAL_ARG_O(_i, ...) \
-  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type
-
-#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
-  const ::testing::Matcher<typename ::testing::internal::Function< \
-      __VA_ARGS__>::template Arg<_i>::type>&
-
-#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
-#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
-#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
-#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
-#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
-#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
-#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
-#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
-#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
-#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
-#define MOCK_METHOD10(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
-#define MOCK_CONST_METHOD1(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
-#define MOCK_CONST_METHOD2(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
-#define MOCK_CONST_METHOD3(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
-#define MOCK_CONST_METHOD4(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
-#define MOCK_CONST_METHOD5(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
-#define MOCK_CONST_METHOD6(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
-#define MOCK_CONST_METHOD7(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
-#define MOCK_CONST_METHOD8(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
-#define MOCK_CONST_METHOD9(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
-#define MOCK_CONST_METHOD10(m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)
-
-#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
-#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
-#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
-#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
-#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
-#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
-#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
-#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
-#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
-#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
-#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)
-
-#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
-#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
-#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
-#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
-#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
-#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
-#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
-#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
-#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
-#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
-#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
-  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)
-
-#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-
-#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
-  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
-
-#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
-  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
-      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
-  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
-      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
-      (::testing::internal::identity_t<__VA_ARGS__>))
-
-#define GMOCK_MOCKER_(arity, constness, Method) \
-  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
+// Copyright 2007, 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. 
+ 
+// Google Mock - a framework for writing C++ mock classes. 
+// 
+// This file implements MOCK_METHOD. 
+ 
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT 
+ 
+#include <type_traits>  // IWYU pragma: keep 
+#include <utility>      // IWYU pragma: keep 
+ 
+#include "gmock/gmock-spec-builders.h" 
+#include "gmock/internal/gmock-internal-utils.h" 
+#include "gmock/internal/gmock-pp.h" 
+ 
+namespace testing { 
+namespace internal { 
+template <typename T> 
+using identity_t = T; 
+ 
+template <typename Pattern> 
+struct ThisRefAdjuster { 
+  template <typename T> 
+  using AdjustT = typename std::conditional< 
+      std::is_const<typename std::remove_reference<Pattern>::type>::value, 
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value, 
+                                const T&, const T&&>::type, 
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&, 
+                                T&&>::type>::type; 
+ 
+  template <typename MockType> 
+  static AdjustT<MockType> Adjust(const MockType& mock) { 
+    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock)); 
+  } 
+}; 
+ 
+}  // namespace internal 
+ 
+// The style guide prohibits "using" statements in a namespace scope 
+// inside a header file.  However, the FunctionMocker class template 
+// is meant to be defined in the ::testing namespace.  The following 
+// line is just a trick for working around a bug in MSVC 8.0, which 
+// cannot handle it if we define FunctionMocker in ::testing. 
+using internal::FunctionMocker; 
+}  // namespace testing 
+ 
+#define MOCK_METHOD(...) \ 
+  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ 
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ 
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ 
+  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \ 
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \ 
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \ 
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \ 
+      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \ 
+  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \ 
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \ 
+      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \ 
+      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \ 
+      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \ 
+      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ 
+      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ 
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ 
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ 
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \ 
+  static_assert(                                                             \ 
+      false,                                                                 \ 
+      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \ 
+      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \ 
+      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ 
+      "it must also be enclosed in parentheses.") 
+ 
+#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ 
+  static_assert(                                  \ 
+      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \ 
+      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") 
+ 
+#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \ 
+  static_assert(                                                       \ 
+      std::is_function<__VA_ARGS__>::value,                            \ 
+      "Signature must be a function type, maybe return type contains " \ 
+      "unprotected comma.");                                           \ 
+  static_assert(                                                       \ 
+      ::testing::tuple_size<typename ::testing::internal::Function<    \ 
+              __VA_ARGS__>::ArgumentTuple>::value == _N,               \ 
+      "This method does not take " GMOCK_PP_STRINGIZE(                 \ 
+          _N) " arguments. Parenthesize all types with unprotected commas.") 
+ 
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \ 
+                                        _Override, _Final, _NoexceptSpec,      \ 
+                                        _CallType, _RefSpec, _Signature)       \ 
+  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \ 
+      _Signature)>::Result                                                     \ 
+  GMOCK_INTERNAL_EXPAND(_CallType)                                             \ 
+      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \ 
+          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \ 
+          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \ 
+    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \ 
+        .SetOwnerAndName(this, #_MethodName);                                  \ 
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \ 
+        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \ 
+  }                                                                            \ 
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ 
+      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \ 
+      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \ 
+    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \ 
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \ 
+        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \ 
+  }                                                                            \ 
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \ 
+      const ::testing::internal::WithoutMatchers&,                             \ 
+      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \ 
+          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ 
+    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \ 
+        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \ 
+        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \ 
+            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \ 
+  }                                                                            \ 
+  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \ 
+      GMOCK_MOCKER_(_N, _Constness, _MethodName) 
+ 
+#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ 
+ 
+// Five Valid modifiers. 
+#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ 
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) 
+ 
+#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ 
+  GMOCK_PP_HAS_COMMA(                       \ 
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) 
+ 
+#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ 
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) 
+ 
+#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) 
+ 
+#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \ 
+  GMOCK_PP_IF(                                                          \ 
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ 
+      _elem, ) 
+ 
+#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) 
+ 
+#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \ 
+  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ 
+              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) 
+ 
+#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple) 
+ 
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \ 
+  static_assert(                                                          \ 
+      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \ 
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ 
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \ 
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ 
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \ 
+       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \ 
+      GMOCK_PP_STRINGIZE(                                                 \ 
+          _elem) " cannot be recognized as a valid specification modifier."); 
+ 
+// Modifiers implementation. 
+#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ 
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) 
+ 
+#define GMOCK_INTERNAL_DETECT_CONST_I_const , 
+ 
+#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ 
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) 
+ 
+#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , 
+ 
+#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ 
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) 
+ 
+#define GMOCK_INTERNAL_DETECT_FINAL_I_final , 
+ 
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ 
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) 
+ 
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , 
+ 
+#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ 
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) 
+ 
+#define GMOCK_INTERNAL_DETECT_REF_I_ref , 
+ 
+#define GMOCK_INTERNAL_UNPACK_ref(x) x 
+ 
+#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \ 
+  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \ 
+              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \ 
+  (_elem) 
+ 
+// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and 
+// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows 
+// maybe they can be simplified somehow. 
+#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \ 
+  GMOCK_INTERNAL_IS_CALLTYPE_I(          \ 
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) 
+#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg) 
+ 
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \ 
+  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \ 
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) 
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \ 
+  GMOCK_PP_IDENTITY _arg 
+ 
+#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype 
+ 
+// Note: The use of `identity_t` here allows _Ret to represent return types that 
+// would normally need to be specified in a different way. For example, a method 
+// returning a function pointer must be written as 
+// 
+// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) 
+// 
+// But we only support placing the return type at the beginning. To handle this, 
+// we wrap all calls in identity_t, so that a declaration will be expanded to 
+// 
+// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...) 
+// 
+// This allows us to work around the syntactic oddities of function/method 
+// types. 
+#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \ 
+  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \ 
+                                              GMOCK_PP_REMOVE_PARENS,         \ 
+                                              GMOCK_PP_IDENTITY)(_Ret)>(      \ 
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) 
+ 
+#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \ 
+  GMOCK_PP_COMMA_IF(_i)                                                \ 
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ 
+              GMOCK_PP_IDENTITY)                                       \ 
+  (_elem) 
+ 
+#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \ 
+  GMOCK_PP_COMMA_IF(_i)                                        \ 
+  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ 
+  gmock_a##_i 
+ 
+#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ 
+  GMOCK_PP_COMMA_IF(_i)                               \ 
+  ::std::forward<GMOCK_INTERNAL_ARG_O(                \ 
+      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i) 
+ 
+#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \ 
+  GMOCK_PP_COMMA_IF(_i)                                            \ 
+  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ 
+  gmock_a##_i 
+ 
+#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ 
+  GMOCK_PP_COMMA_IF(_i)                             \ 
+  gmock_a##_i 
+ 
+#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ 
+  GMOCK_PP_COMMA_IF(_i)                                      \ 
+  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>() 
+ 
+#define GMOCK_INTERNAL_ARG_O(_i, ...) \ 
+  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type 
+ 
+#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \ 
+  const ::testing::Matcher<typename ::testing::internal::Function< \ 
+      __VA_ARGS__>::template Arg<_i>::type>& 
+ 
+#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) 
+#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) 
+#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) 
+#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) 
+#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) 
+#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) 
+#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) 
+#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) 
+#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) 
+#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) 
+#define MOCK_METHOD10(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) 
+ 
+#define MOCK_CONST_METHOD0(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) 
+#define MOCK_CONST_METHOD1(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) 
+#define MOCK_CONST_METHOD2(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) 
+#define MOCK_CONST_METHOD3(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) 
+#define MOCK_CONST_METHOD4(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) 
+#define MOCK_CONST_METHOD5(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) 
+#define MOCK_CONST_METHOD6(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) 
+#define MOCK_CONST_METHOD7(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) 
+#define MOCK_CONST_METHOD8(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) 
+#define MOCK_CONST_METHOD9(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) 
+#define MOCK_CONST_METHOD10(m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) 
+ 
+#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) 
+#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) 
+#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) 
+#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) 
+#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) 
+#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) 
+#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) 
+#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) 
+#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) 
+#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) 
+#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) 
+ 
+#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) 
+ 
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) 
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) 
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) 
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) 
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) 
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) 
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) 
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) 
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) 
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) 
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) 
+ 
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) 
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) 
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) 
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) 
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) 
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) 
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) 
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) 
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) 
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) 
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ 
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) 
+ 
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+ 
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ 
+  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) 
+ 
+#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ 
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \ 
+      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \ 
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \ 
+      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \ 
+      (::testing::internal::identity_t<__VA_ARGS__>)) 
+ 
+#define GMOCK_MOCKER_(arity, constness, Method) \ 
+  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-matchers.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-matchers.h
index 86be9c176e..d386fb6f86 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -27,264 +27,264 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
-// The MATCHER* family of macros can be used in a namespace scope to
-// define custom matchers easily.
-//
-// Basic Usage
-// ===========
-//
-// The syntax
-//
-//   MATCHER(name, description_string) { statements; }
-//
-// defines a matcher with the given name that executes the statements,
-// which must return a bool to indicate if the match succeeds.  Inside
-// the statements, you can refer to the value being matched by 'arg',
-// and refer to its type by 'arg_type'.
-//
-// The description string documents what the matcher does, and is used
-// to generate the failure message when the match fails.  Since a
-// MATCHER() is usually defined in a header file shared by multiple
-// C++ source files, we require the description to be a C-string
-// literal to avoid possible side effects.  It can be empty, in which
-// case we'll use the sequence of words in the matcher name as the
-// description.
-//
-// For example:
-//
-//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
-//
-// allows you to write
-//
-//   // Expects mock_foo.Bar(n) to be called where n is even.
-//   EXPECT_CALL(mock_foo, Bar(IsEven()));
-//
-// or,
-//
-//   // Verifies that the value of some_expression is even.
-//   EXPECT_THAT(some_expression, IsEven());
-//
-// If the above assertion fails, it will print something like:
-//
-//   Value of: some_expression
-//   Expected: is even
-//     Actual: 7
-//
-// where the description "is even" is automatically calculated from the
-// matcher name IsEven.
-//
-// Argument Type
-// =============
-//
-// Note that the type of the value being matched (arg_type) is
-// determined by the context in which you use the matcher and is
-// supplied to you by the compiler, so you don't need to worry about
-// declaring it (nor can you).  This allows the matcher to be
-// polymorphic.  For example, IsEven() can be used to match any type
-// where the value of "(arg % 2) == 0" can be implicitly converted to
-// a bool.  In the "Bar(IsEven())" example above, if method Bar()
-// takes an int, 'arg_type' will be int; if it takes an unsigned long,
-// 'arg_type' will be unsigned long; and so on.
-//
-// Parameterizing Matchers
-// =======================
-//
-// Sometimes you'll want to parameterize the matcher.  For that you
-// can use another macro:
-//
-//   MATCHER_P(name, param_name, description_string) { statements; }
-//
-// For example:
-//
-//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
-//
-// will allow you to write:
-//
-//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
-//
-// which may lead to this message (assuming n is 10):
-//
-//   Value of: Blah("a")
-//   Expected: has absolute value 10
-//     Actual: -9
-//
-// Note that both the matcher description and its parameter are
-// printed, making the message human-friendly.
-//
-// In the matcher definition body, you can write 'foo_type' to
-// reference the type of a parameter named 'foo'.  For example, in the
-// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
-// 'value_type' to refer to the type of 'value'.
-//
-// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
-// support multi-parameter matchers.
-//
-// Describing Parameterized Matchers
-// =================================
-//
-// The last argument to MATCHER*() is a string-typed expression.  The
-// expression can reference all of the matcher's parameters and a
-// special bool-typed variable named 'negation'.  When 'negation' is
-// false, the expression should evaluate to the matcher's description;
-// otherwise it should evaluate to the description of the negation of
-// the matcher.  For example,
-//
-//   using testing::PrintToString;
-//
-//   MATCHER_P2(InClosedRange, low, hi,
-//       std::string(negation ? "is not" : "is") + " in range [" +
-//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
-//     return low <= arg && arg <= hi;
-//   }
-//   ...
-//   EXPECT_THAT(3, InClosedRange(4, 6));
-//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
-//
-// would generate two failures that contain the text:
-//
-//   Expected: is in range [4, 6]
-//   ...
-//   Expected: is not in range [2, 4]
-//
-// If you specify "" as the description, the failure message will
-// contain the sequence of words in the matcher name followed by the
-// parameter values printed as a tuple.  For example,
-//
-//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
-//   ...
-//   EXPECT_THAT(3, InClosedRange(4, 6));
-//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
-//
-// would generate two failures that contain the text:
-//
-//   Expected: in closed range (4, 6)
-//   ...
-//   Expected: not (in closed range (2, 4))
-//
-// Types of Matcher Parameters
-// ===========================
-//
-// For the purpose of typing, you can view
-//
-//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
-//
-// as shorthand for
-//
-//   template <typename p1_type, ..., typename pk_type>
-//   FooMatcherPk<p1_type, ..., pk_type>
-//   Foo(p1_type p1, ..., pk_type pk) { ... }
-//
-// When you write Foo(v1, ..., vk), the compiler infers the types of
-// the parameters v1, ..., and vk for you.  If you are not happy with
-// the result of the type inference, you can specify the types by
-// explicitly instantiating the template, as in Foo<long, bool>(5,
-// false).  As said earlier, you don't get to (or need to) specify
-// 'arg_type' as that's determined by the context in which the matcher
-// is used.  You can assign the result of expression Foo(p1, ..., pk)
-// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
-// can be useful when composing matchers.
-//
-// While you can instantiate a matcher template with reference types,
-// passing the parameters by pointer usually makes your code more
-// readable.  If, however, you still want to pass a parameter by
-// reference, be aware that in the failure message generated by the
-// matcher you will see the value of the referenced object but not its
-// address.
-//
-// Explaining Match Results
-// ========================
-//
-// Sometimes the matcher description alone isn't enough to explain why
-// the match has failed or succeeded.  For example, when expecting a
-// long string, it can be very helpful to also print the diff between
-// the expected string and the actual one.  To achieve that, you can
-// optionally stream additional information to a special variable
-// named result_listener, whose type is a pointer to class
-// MatchResultListener:
-//
-//   MATCHER_P(EqualsLongString, str, "") {
-//     if (arg == str) return true;
-//
-//     *result_listener << "the difference: "
-///                     << DiffStrings(str, arg);
-//     return false;
-//   }
-//
-// Overloading Matchers
-// ====================
-//
-// You can overload matchers with different numbers of parameters:
-//
-//   MATCHER_P(Blah, a, description_string1) { ... }
-//   MATCHER_P2(Blah, a, b, description_string2) { ... }
-//
-// Caveats
-// =======
-//
-// When defining a new matcher, you should also consider implementing
-// MatcherInterface or using MakePolymorphicMatcher().  These
-// approaches require more work than the MATCHER* macros, but also
-// give you more control on the types of the value being matched and
-// the matcher parameters, which may leads to better compiler error
-// messages when the matcher is used wrong.  They also allow
-// overloading matchers based on parameter types (as opposed to just
-// based on the number of parameters).
-//
-// MATCHER*() can only be used in a namespace scope as templates cannot be
-// declared inside of a local class.
-//
-// More Information
-// ================
-//
-// To learn more about using these macros, please search for 'MATCHER'
-// on
-// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
-//
-// This file also implements some commonly used argument matchers.  More
+// The MATCHER* family of macros can be used in a namespace scope to 
+// define custom matchers easily. 
+// 
+// Basic Usage 
+// =========== 
+// 
+// The syntax 
+// 
+//   MATCHER(name, description_string) { statements; } 
+// 
+// defines a matcher with the given name that executes the statements, 
+// which must return a bool to indicate if the match succeeds.  Inside 
+// the statements, you can refer to the value being matched by 'arg', 
+// and refer to its type by 'arg_type'. 
+// 
+// The description string documents what the matcher does, and is used 
+// to generate the failure message when the match fails.  Since a 
+// MATCHER() is usually defined in a header file shared by multiple 
+// C++ source files, we require the description to be a C-string 
+// literal to avoid possible side effects.  It can be empty, in which 
+// case we'll use the sequence of words in the matcher name as the 
+// description. 
+// 
+// For example: 
+// 
+//   MATCHER(IsEven, "") { return (arg % 2) == 0; } 
+// 
+// allows you to write 
+// 
+//   // Expects mock_foo.Bar(n) to be called where n is even. 
+//   EXPECT_CALL(mock_foo, Bar(IsEven())); 
+// 
+// or, 
+// 
+//   // Verifies that the value of some_expression is even. 
+//   EXPECT_THAT(some_expression, IsEven()); 
+// 
+// If the above assertion fails, it will print something like: 
+// 
+//   Value of: some_expression 
+//   Expected: is even 
+//     Actual: 7 
+// 
+// where the description "is even" is automatically calculated from the 
+// matcher name IsEven. 
+// 
+// Argument Type 
+// ============= 
+// 
+// Note that the type of the value being matched (arg_type) is 
+// determined by the context in which you use the matcher and is 
+// supplied to you by the compiler, so you don't need to worry about 
+// declaring it (nor can you).  This allows the matcher to be 
+// polymorphic.  For example, IsEven() can be used to match any type 
+// where the value of "(arg % 2) == 0" can be implicitly converted to 
+// a bool.  In the "Bar(IsEven())" example above, if method Bar() 
+// takes an int, 'arg_type' will be int; if it takes an unsigned long, 
+// 'arg_type' will be unsigned long; and so on. 
+// 
+// Parameterizing Matchers 
+// ======================= 
+// 
+// Sometimes you'll want to parameterize the matcher.  For that you 
+// can use another macro: 
+// 
+//   MATCHER_P(name, param_name, description_string) { statements; } 
+// 
+// For example: 
+// 
+//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } 
+// 
+// will allow you to write: 
+// 
+//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); 
+// 
+// which may lead to this message (assuming n is 10): 
+// 
+//   Value of: Blah("a") 
+//   Expected: has absolute value 10 
+//     Actual: -9 
+// 
+// Note that both the matcher description and its parameter are 
+// printed, making the message human-friendly. 
+// 
+// In the matcher definition body, you can write 'foo_type' to 
+// reference the type of a parameter named 'foo'.  For example, in the 
+// body of MATCHER_P(HasAbsoluteValue, value) above, you can write 
+// 'value_type' to refer to the type of 'value'. 
+// 
+// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to 
+// support multi-parameter matchers. 
+// 
+// Describing Parameterized Matchers 
+// ================================= 
+// 
+// The last argument to MATCHER*() is a string-typed expression.  The 
+// expression can reference all of the matcher's parameters and a 
+// special bool-typed variable named 'negation'.  When 'negation' is 
+// false, the expression should evaluate to the matcher's description; 
+// otherwise it should evaluate to the description of the negation of 
+// the matcher.  For example, 
+// 
+//   using testing::PrintToString; 
+// 
+//   MATCHER_P2(InClosedRange, low, hi, 
+//       std::string(negation ? "is not" : "is") + " in range [" + 
+//       PrintToString(low) + ", " + PrintToString(hi) + "]") { 
+//     return low <= arg && arg <= hi; 
+//   } 
+//   ... 
+//   EXPECT_THAT(3, InClosedRange(4, 6)); 
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4))); 
+// 
+// would generate two failures that contain the text: 
+// 
+//   Expected: is in range [4, 6] 
+//   ... 
+//   Expected: is not in range [2, 4] 
+// 
+// If you specify "" as the description, the failure message will 
+// contain the sequence of words in the matcher name followed by the 
+// parameter values printed as a tuple.  For example, 
+// 
+//   MATCHER_P2(InClosedRange, low, hi, "") { ... } 
+//   ... 
+//   EXPECT_THAT(3, InClosedRange(4, 6)); 
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4))); 
+// 
+// would generate two failures that contain the text: 
+// 
+//   Expected: in closed range (4, 6) 
+//   ... 
+//   Expected: not (in closed range (2, 4)) 
+// 
+// Types of Matcher Parameters 
+// =========================== 
+// 
+// For the purpose of typing, you can view 
+// 
+//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } 
+// 
+// as shorthand for 
+// 
+//   template <typename p1_type, ..., typename pk_type> 
+//   FooMatcherPk<p1_type, ..., pk_type> 
+//   Foo(p1_type p1, ..., pk_type pk) { ... } 
+// 
+// When you write Foo(v1, ..., vk), the compiler infers the types of 
+// the parameters v1, ..., and vk for you.  If you are not happy with 
+// the result of the type inference, you can specify the types by 
+// explicitly instantiating the template, as in Foo<long, bool>(5, 
+// false).  As said earlier, you don't get to (or need to) specify 
+// 'arg_type' as that's determined by the context in which the matcher 
+// is used.  You can assign the result of expression Foo(p1, ..., pk) 
+// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This 
+// can be useful when composing matchers. 
+// 
+// While you can instantiate a matcher template with reference types, 
+// passing the parameters by pointer usually makes your code more 
+// readable.  If, however, you still want to pass a parameter by 
+// reference, be aware that in the failure message generated by the 
+// matcher you will see the value of the referenced object but not its 
+// address. 
+// 
+// Explaining Match Results 
+// ======================== 
+// 
+// Sometimes the matcher description alone isn't enough to explain why 
+// the match has failed or succeeded.  For example, when expecting a 
+// long string, it can be very helpful to also print the diff between 
+// the expected string and the actual one.  To achieve that, you can 
+// optionally stream additional information to a special variable 
+// named result_listener, whose type is a pointer to class 
+// MatchResultListener: 
+// 
+//   MATCHER_P(EqualsLongString, str, "") { 
+//     if (arg == str) return true; 
+// 
+//     *result_listener << "the difference: " 
+///                     << DiffStrings(str, arg); 
+//     return false; 
+//   } 
+// 
+// Overloading Matchers 
+// ==================== 
+// 
+// You can overload matchers with different numbers of parameters: 
+// 
+//   MATCHER_P(Blah, a, description_string1) { ... } 
+//   MATCHER_P2(Blah, a, b, description_string2) { ... } 
+// 
+// Caveats 
+// ======= 
+// 
+// When defining a new matcher, you should also consider implementing 
+// MatcherInterface or using MakePolymorphicMatcher().  These 
+// approaches require more work than the MATCHER* macros, but also 
+// give you more control on the types of the value being matched and 
+// the matcher parameters, which may leads to better compiler error 
+// messages when the matcher is used wrong.  They also allow 
+// overloading matchers based on parameter types (as opposed to just 
+// based on the number of parameters). 
+// 
+// MATCHER*() can only be used in a namespace scope as templates cannot be 
+// declared inside of a local class. 
+// 
+// More Information 
+// ================ 
+// 
+// To learn more about using these macros, please search for 'MATCHER' 
+// on 
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md 
+// 
+// This file also implements some commonly used argument matchers.  More 
 // matchers can be defined by the user implementing the
 // MatcherInterface<T> interface if necessary.
-//
-// See googletest/include/gtest/gtest-matchers.h for the definition of class
-// Matcher, class MatcherInterface, and others.
-
-// GOOGLETEST_CM0002 DO NOT DELETE
+// 
+// See googletest/include/gtest/gtest-matchers.h for the definition of class 
+// Matcher, class MatcherInterface, and others. 
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 
 
 #include <algorithm>
-#include <cmath>
-#include <initializer_list>
+#include <cmath> 
+#include <initializer_list> 
 #include <iterator>
 #include <limits>
-#include <memory>
+#include <memory> 
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
-#include <type_traits>
+#include <type_traits> 
 #include <utility>
 #include <vector>
-
+ 
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gmock/internal/gmock-port.h"
-#include "gmock/internal/gmock-pp.h"
+#include "gmock/internal/gmock-pp.h" 
 #include "gtest/gtest.h"
 
-// MSVC warning C5046 is new as of VS2017 version 15.8.
-#if defined(_MSC_VER) && _MSC_VER >= 1915
-#define GMOCK_MAYBE_5046_ 5046
-#else
-#define GMOCK_MAYBE_5046_
+// MSVC warning C5046 is new as of VS2017 version 15.8. 
+#if defined(_MSC_VER) && _MSC_VER >= 1915 
+#define GMOCK_MAYBE_5046_ 5046 
+#else 
+#define GMOCK_MAYBE_5046_ 
 #endif
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(
-    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
-                              clients of class B */
-    /* Symbol involving type with internal linkage not defined */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_( 
+    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by 
+                              clients of class B */ 
+    /* Symbol involving type with internal linkage not defined */) 
+ 
 namespace testing {
 
 // To implement a matcher Foo for type T, define:
@@ -305,7 +305,7 @@ class StringMatchResultListener : public MatchResultListener {
   StringMatchResultListener() : MatchResultListener(&ss_) {}
 
   // Returns the explanation accumulated so far.
-  std::string str() const { return ss_.str(); }
+  std::string str() const { return ss_.str(); } 
 
   // Clears the explanation accumulated so far.
   void Clear() { ss_.str(""); }
@@ -334,7 +334,7 @@ template <typename T, typename M>
 class MatcherCastImpl {
  public:
   static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
-    // M can be a polymorphic matcher, in which case we want to use
+    // M can be a polymorphic matcher, in which case we want to use 
     // its conversion operator to create Matcher<T>.  Or it can be a value
     // that should be passed to the Matcher<T>'s constructor.
     //
@@ -343,22 +343,22 @@ class MatcherCastImpl {
     // constructor from M (this usually happens when T has an implicit
     // constructor from any type).
     //
-    // It won't work to unconditionally implicit_cast
+    // It won't work to unconditionally implicit_cast 
     // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
     // a user-defined conversion from M to T if one exists (assuming M is
     // a value).
-    return CastImpl(polymorphic_matcher_or_value,
-                    std::is_convertible<M, Matcher<T>>{},
-                    std::is_convertible<M, T>{});
+    return CastImpl(polymorphic_matcher_or_value, 
+                    std::is_convertible<M, Matcher<T>>{}, 
+                    std::is_convertible<M, T>{}); 
   }
 
  private:
-  template <bool Ignore>
+  template <bool Ignore> 
   static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
-                             std::true_type /* convertible_to_matcher */,
-                             std::integral_constant<bool, Ignore>) {
+                             std::true_type /* convertible_to_matcher */, 
+                             std::integral_constant<bool, Ignore>) { 
     // M is implicitly convertible to Matcher<T>, which means that either
-    // M is a polymorphic matcher or Matcher<T> has an implicit constructor
+    // M is a polymorphic matcher or Matcher<T> has an implicit constructor 
     // from M.  In both cases using the implicit conversion will produce a
     // matcher.
     //
@@ -367,29 +367,29 @@ class MatcherCastImpl {
     // (first to create T from M and then to create Matcher<T> from T).
     return polymorphic_matcher_or_value;
   }
-
-  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
-  // matcher. It's a value of a type implicitly convertible to T. Use direct
-  // initialization to create a matcher.
-  static Matcher<T> CastImpl(const M& value,
-                             std::false_type /* convertible_to_matcher */,
-                             std::true_type /* convertible_to_T */) {
-    return Matcher<T>(ImplicitCast_<T>(value));
-  }
-
-  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use
-  // polymorphic matcher Eq(value) in this case.
-  //
-  // Note that we first attempt to perform an implicit cast on the value and
-  // only fall back to the polymorphic Eq() matcher afterwards because the
-  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
-  // which might be undefined even when Rhs is implicitly convertible to Lhs
-  // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
-  //
-  // We don't define this method inline as we need the declaration of Eq().
-  static Matcher<T> CastImpl(const M& value,
-                             std::false_type /* convertible_to_matcher */,
-                             std::false_type /* convertible_to_T */);
+ 
+  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic 
+  // matcher. It's a value of a type implicitly convertible to T. Use direct 
+  // initialization to create a matcher. 
+  static Matcher<T> CastImpl(const M& value, 
+                             std::false_type /* convertible_to_matcher */, 
+                             std::true_type /* convertible_to_T */) { 
+    return Matcher<T>(ImplicitCast_<T>(value)); 
+  } 
+ 
+  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use 
+  // polymorphic matcher Eq(value) in this case. 
+  // 
+  // Note that we first attempt to perform an implicit cast on the value and 
+  // only fall back to the polymorphic Eq() matcher afterwards because the 
+  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end 
+  // which might be undefined even when Rhs is implicitly convertible to Lhs 
+  // (e.g. std::pair<const int, int> vs. std::pair<int, int>). 
+  // 
+  // We don't define this method inline as we need the declaration of Eq(). 
+  static Matcher<T> CastImpl(const M& value, 
+                             std::false_type /* convertible_to_matcher */, 
+                             std::false_type /* convertible_to_T */); 
 };
 
 // This more specialized version is used when MatcherCast()'s argument
@@ -409,36 +409,36 @@ class MatcherCastImpl<T, Matcher<U> > {
         : source_matcher_(source_matcher) {}
 
     // We delegate the matching logic to the source matcher.
-    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
-      using FromType = typename std::remove_cv<typename std::remove_pointer<
-          typename std::remove_reference<T>::type>::type>::type;
-      using ToType = typename std::remove_cv<typename std::remove_pointer<
-          typename std::remove_reference<U>::type>::type>::type;
-      // Do not allow implicitly converting base*/& to derived*/&.
-      static_assert(
-          // Do not trigger if only one of them is a pointer. That implies a
-          // regular conversion and not a down_cast.
-          (std::is_pointer<typename std::remove_reference<T>::type>::value !=
-           std::is_pointer<typename std::remove_reference<U>::type>::value) ||
-              std::is_same<FromType, ToType>::value ||
-              !std::is_base_of<FromType, ToType>::value,
-          "Can't implicitly convert from <base> to <derived>");
-
-      // Do the cast to `U` explicitly if necessary.
-      // Otherwise, let implicit conversions do the trick.
-      using CastType =
-          typename std::conditional<std::is_convertible<T&, const U&>::value,
-                                    T&, U>::type;
-
-      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
-                                             listener);
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override { 
+      using FromType = typename std::remove_cv<typename std::remove_pointer< 
+          typename std::remove_reference<T>::type>::type>::type; 
+      using ToType = typename std::remove_cv<typename std::remove_pointer< 
+          typename std::remove_reference<U>::type>::type>::type; 
+      // Do not allow implicitly converting base*/& to derived*/&. 
+      static_assert( 
+          // Do not trigger if only one of them is a pointer. That implies a 
+          // regular conversion and not a down_cast. 
+          (std::is_pointer<typename std::remove_reference<T>::type>::value != 
+           std::is_pointer<typename std::remove_reference<U>::type>::value) || 
+              std::is_same<FromType, ToType>::value || 
+              !std::is_base_of<FromType, ToType>::value, 
+          "Can't implicitly convert from <base> to <derived>"); 
+ 
+      // Do the cast to `U` explicitly if necessary. 
+      // Otherwise, let implicit conversions do the trick. 
+      using CastType = 
+          typename std::conditional<std::is_convertible<T&, const U&>::value, 
+                                    T&, U>::type; 
+ 
+      return source_matcher_.MatchAndExplain(static_cast<CastType>(x), 
+                                             listener); 
     }
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       source_matcher_.DescribeTo(os);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       source_matcher_.DescribeNegationTo(os);
     }
 
@@ -455,50 +455,50 @@ class MatcherCastImpl<T, Matcher<T> > {
   static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
 };
 
-// Template specialization for parameterless Matcher.
-template <typename Derived>
-class MatcherBaseImpl {
- public:
-  MatcherBaseImpl() = default;
-
-  template <typename T>
-  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit)
-    return ::testing::Matcher<T>(new
-                                 typename Derived::template gmock_Impl<T>());
-  }
-};
-
-// Template specialization for Matcher with parameters.
-template <template <typename...> class Derived, typename... Ts>
-class MatcherBaseImpl<Derived<Ts...>> {
- public:
-  // Mark the constructor explicit for single argument T to avoid implicit
-  // conversions.
-  template <typename E = std::enable_if<sizeof...(Ts) == 1>,
-            typename E::type* = nullptr>
-  explicit MatcherBaseImpl(Ts... params)
-      : params_(std::forward<Ts>(params)...) {}
-  template <typename E = std::enable_if<sizeof...(Ts) != 1>,
-            typename = typename E::type>
-  MatcherBaseImpl(Ts... params)  // NOLINT
-      : params_(std::forward<Ts>(params)...) {}
-
-  template <typename F>
-  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
-    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
-  }
-
- private:
-  template <typename F, std::size_t... tuple_ids>
-  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
-    return ::testing::Matcher<F>(
-        new typename Derived<Ts...>::template gmock_Impl<F>(
-            std::get<tuple_ids>(params_)...));
-  }
-
-  const std::tuple<Ts...> params_;
-};
-
+// Template specialization for parameterless Matcher. 
+template <typename Derived> 
+class MatcherBaseImpl { 
+ public: 
+  MatcherBaseImpl() = default; 
+ 
+  template <typename T> 
+  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit) 
+    return ::testing::Matcher<T>(new 
+                                 typename Derived::template gmock_Impl<T>()); 
+  } 
+}; 
+ 
+// Template specialization for Matcher with parameters. 
+template <template <typename...> class Derived, typename... Ts> 
+class MatcherBaseImpl<Derived<Ts...>> { 
+ public: 
+  // Mark the constructor explicit for single argument T to avoid implicit 
+  // conversions. 
+  template <typename E = std::enable_if<sizeof...(Ts) == 1>, 
+            typename E::type* = nullptr> 
+  explicit MatcherBaseImpl(Ts... params) 
+      : params_(std::forward<Ts>(params)...) {} 
+  template <typename E = std::enable_if<sizeof...(Ts) != 1>, 
+            typename = typename E::type> 
+  MatcherBaseImpl(Ts... params)  // NOLINT 
+      : params_(std::forward<Ts>(params)...) {} 
+ 
+  template <typename F> 
+  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit) 
+    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{}); 
+  } 
+ 
+ private: 
+  template <typename F, std::size_t... tuple_ids> 
+  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const { 
+    return ::testing::Matcher<F>( 
+        new typename Derived<Ts...>::template gmock_Impl<F>( 
+            std::get<tuple_ids>(params_)...)); 
+  } 
+ 
+  const std::tuple<Ts...> params_; 
+}; 
+ 
 }  // namespace internal
 
 // In order to be safe and clear, casting between different matcher
@@ -510,45 +510,45 @@ inline Matcher<T> MatcherCast(const M& matcher) {
   return internal::MatcherCastImpl<T, M>::Cast(matcher);
 }
 
-// This overload handles polymorphic matchers and values only since
-// monomorphic matchers are handled by the next one.
+// This overload handles polymorphic matchers and values only since 
+// monomorphic matchers are handled by the next one. 
 template <typename T, typename M>
-inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
-  return MatcherCast<T>(polymorphic_matcher_or_value);
-}
-
-// This overload handles monomorphic matchers.
-//
-// In general, if type T can be implicitly converted to type U, we can
-// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
-// contravariant): just keep a copy of the original Matcher<U>, convert the
-// argument from type T to U, and then pass it to the underlying Matcher<U>.
-// The only exception is when U is a reference and T is not, as the
-// underlying Matcher<U> may be interested in the argument's address, which
-// is not preserved in the conversion from T to U.
-template <typename T, typename U>
-inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
-  // Enforce that T can be implicitly converted to U.
-  static_assert(std::is_convertible<const T&, const U&>::value,
-                "T must be implicitly convertible to U");
-  // Enforce that we are not converting a non-reference type T to a reference
-  // type U.
-  GTEST_COMPILE_ASSERT_(
-      std::is_reference<T>::value || !std::is_reference<U>::value,
-      cannot_convert_non_reference_arg_to_reference);
-  // In case both T and U are arithmetic types, enforce that the
-  // conversion is not lossy.
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
-  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
-  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
-  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
-  GTEST_COMPILE_ASSERT_(
-      kTIsOther || kUIsOther ||
-      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
-      conversion_of_arithmetic_types_must_be_lossless);
-  return MatcherCast<T>(matcher);
-}
-
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) { 
+  return MatcherCast<T>(polymorphic_matcher_or_value); 
+}
+
+// This overload handles monomorphic matchers. 
+// 
+// In general, if type T can be implicitly converted to type U, we can 
+// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is 
+// contravariant): just keep a copy of the original Matcher<U>, convert the 
+// argument from type T to U, and then pass it to the underlying Matcher<U>. 
+// The only exception is when U is a reference and T is not, as the 
+// underlying Matcher<U> may be interested in the argument's address, which 
+// is not preserved in the conversion from T to U. 
+template <typename T, typename U> 
+inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) { 
+  // Enforce that T can be implicitly converted to U. 
+  static_assert(std::is_convertible<const T&, const U&>::value, 
+                "T must be implicitly convertible to U"); 
+  // Enforce that we are not converting a non-reference type T to a reference 
+  // type U. 
+  GTEST_COMPILE_ASSERT_( 
+      std::is_reference<T>::value || !std::is_reference<U>::value, 
+      cannot_convert_non_reference_arg_to_reference); 
+  // In case both T and U are arithmetic types, enforce that the 
+  // conversion is not lossy. 
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT; 
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU; 
+  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther; 
+  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther; 
+  GTEST_COMPILE_ASSERT_( 
+      kTIsOther || kUIsOther || 
+      (internal::LosslessArithmeticConvertible<RawT, RawU>::value), 
+      conversion_of_arithmetic_types_must_be_lossless); 
+  return MatcherCast<T>(matcher); 
+} 
+ 
 // A<T>() returns a matcher that matches any value of type T.
 template <typename T>
 Matcher<T> A();
@@ -558,9 +558,9 @@ Matcher<T> A();
 namespace internal {
 
 // If the explanation is not empty, prints it to the ostream.
-inline void PrintIfNotEmpty(const std::string& explanation,
+inline void PrintIfNotEmpty(const std::string& explanation, 
                             ::std::ostream* os) {
-  if (explanation != "" && os != nullptr) {
+  if (explanation != "" && os != nullptr) { 
     *os << ", " << explanation;
   }
 }
@@ -568,11 +568,11 @@ inline void PrintIfNotEmpty(const std::string& explanation,
 // Returns true if the given type name is easy to read by a human.
 // This is used to decide whether printing the type of a value might
 // be helpful.
-inline bool IsReadableTypeName(const std::string& type_name) {
+inline bool IsReadableTypeName(const std::string& type_name) { 
   // We consider a type name readable if it's short or doesn't contain
   // a template or function type.
   return (type_name.length() <= 20 ||
-          type_name.find_first_of("<(") == std::string::npos);
+          type_name.find_first_of("<(") == std::string::npos); 
 }
 
 // Matches the value against the given matcher, prints the value and explains
@@ -594,7 +594,7 @@ bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
 
   UniversalPrint(value, listener->stream());
 #if GTEST_HAS_RTTI
-  const std::string& type_name = GetTypeName<Value>();
+  const std::string& type_name = GetTypeName<Value>(); 
   if (IsReadableTypeName(type_name))
     *listener->stream() << " (of type " << type_name << ")";
 #endif
@@ -609,13 +609,13 @@ template <size_t N>
 class TuplePrefix {
  public:
   // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
-  // if and only if the first N fields of matcher_tuple matches
-  // the first N fields of value_tuple, respectively.
+  // if and only if the first N fields of matcher_tuple matches 
+  // the first N fields of value_tuple, respectively. 
   template <typename MatcherTuple, typename ValueTuple>
   static bool Matches(const MatcherTuple& matcher_tuple,
                       const ValueTuple& value_tuple) {
-    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
-           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));
+    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) && 
+           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple)); 
   }
 
   // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
@@ -631,14 +631,14 @@ class TuplePrefix {
 
     // Then describes the failure (if any) in the (N - 1)-th (0-based)
     // field.
-    typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
-        std::get<N - 1>(matchers);
-    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
-    const Value& value = std::get<N - 1>(values);
+    typename std::tuple_element<N - 1, MatcherTuple>::type matcher = 
+        std::get<N - 1>(matchers); 
+    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value; 
+    const Value& value = std::get<N - 1>(values); 
     StringMatchResultListener listener;
     if (!matcher.MatchAndExplain(value, &listener)) {
       *os << "  Expected arg #" << N - 1 << ": ";
-      std::get<N - 1>(matchers).DescribeTo(os);
+      std::get<N - 1>(matchers).DescribeTo(os); 
       *os << "\n           Actual: ";
       // We remove the reference in type Value to prevent the
       // universal printer from printing the address of value, which
@@ -668,8 +668,8 @@ class TuplePrefix<0> {
                                      ::std::ostream* /* os */) {}
 };
 
-// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
-// all matchers in matcher_tuple match the corresponding fields in
+// TupleMatches(matcher_tuple, value_tuple) returns true if and only if 
+// all matchers in matcher_tuple match the corresponding fields in 
 // value_tuple.  It is a compiler error if matcher_tuple and
 // value_tuple have different number of fields or incompatible field
 // types.
@@ -678,11 +678,11 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
                   const ValueTuple& value_tuple) {
   // Makes sure that matcher_tuple and value_tuple have the same
   // number of fields.
-  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
-                            std::tuple_size<ValueTuple>::value,
+  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value == 
+                            std::tuple_size<ValueTuple>::value, 
                         matcher_and_value_have_different_numbers_of_fields);
-  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
-                                                                  value_tuple);
+  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple, 
+                                                                  value_tuple); 
 }
 
 // Describes failures in matching matchers against values.  If there
@@ -691,7 +691,7 @@ template <typename MatcherTuple, typename ValueTuple>
 void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
                                 const ValueTuple& values,
                                 ::std::ostream* os) {
-  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo( 
       matchers, values, os);
 }
 
@@ -702,7 +702,7 @@ void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
 template <typename Tuple, typename Func, typename OutIter>
 class TransformTupleValuesHelper {
  private:
-  typedef ::std::tuple_size<Tuple> TupleSize;
+  typedef ::std::tuple_size<Tuple> TupleSize; 
 
  public:
   // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
@@ -715,7 +715,7 @@ class TransformTupleValuesHelper {
   template <typename Tup, size_t kRemainingSize>
   struct IterateOverTuple {
     OutIter operator() (Func f, const Tup& t, OutIter out) const {
-      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
+      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t)); 
       return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
     }
   };
@@ -735,21 +735,21 @@ OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
   return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
 }
 
-// Implements _, a matcher that matches any value of any
-// type.  This is a polymorphic matcher, so we need a template type
-// conversion operator to make it appearing as a Matcher<T> for any
-// type T.
-class AnythingMatcher {
+// Implements _, a matcher that matches any value of any 
+// type.  This is a polymorphic matcher, so we need a template type 
+// conversion operator to make it appearing as a Matcher<T> for any 
+// type T. 
+class AnythingMatcher { 
  public:
-  using is_gtest_matcher = void;
-
-  template <typename T>
-  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {
-    return true;
-  }
-  void DescribeTo(std::ostream* os) const { *os << "is anything"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    // This is mostly for completeness' sake, as it's not very useful
+  using is_gtest_matcher = void; 
+ 
+  template <typename T> 
+  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const { 
+    return true; 
+  } 
+  void DescribeTo(std::ostream* os) const { *os << "is anything"; } 
+  void DescribeNegationTo(::std::ostream* os) const { 
+    // This is mostly for completeness' sake, as it's not very useful 
     // to write Not(A<bool>()).  However we cannot completely rule out
     // such a possibility, and it doesn't hurt to be prepared.
     *os << "never matches";
@@ -835,18 +835,18 @@ class RefMatcher<T&> {
 
     // MatchAndExplain() takes a Super& (as opposed to const Super&)
     // in order to match the interface MatcherInterface<Super&>.
-    bool MatchAndExplain(Super& x,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(Super& x, 
+                         MatchResultListener* listener) const override { 
       *listener << "which is located @" << static_cast<const void*>(&x);
       return &x == &object_;
     }
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "references the variable ";
       UniversalPrinter<Super&>::Print(object_, os);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "does not reference the variable ";
       UniversalPrinter<Super&>::Print(object_, os);
     }
@@ -897,21 +897,21 @@ bool CaseInsensitiveStringEquals(const StringType& s1,
 template <typename StringType>
 class StrEqualityMatcher {
  public:
-  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
-      : string_(std::move(str)),
-        expect_eq_(expect_eq),
-        case_sensitive_(case_sensitive) {}
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  bool MatchAndExplain(const internal::StringView& s,
-                       MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
-    // strings.
-    const StringType& str = std::string(s);
-    return MatchAndExplain(str, listener);
-  }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
+  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive) 
+      : string_(std::move(str)), 
+        expect_eq_(expect_eq), 
+        case_sensitive_(case_sensitive) {} 
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  bool MatchAndExplain(const internal::StringView& s, 
+                       MatchResultListener* listener) const { 
+    // This should fail to compile if StringView is used with wide 
+    // strings. 
+    const StringType& str = std::string(s); 
+    return MatchAndExplain(str, listener); 
+  } 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
   // Accepts pointer types, particularly:
   //   const char*
   //   char*
@@ -919,7 +919,7 @@ class StrEqualityMatcher {
   //   wchar_t*
   template <typename CharType>
   bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    if (s == nullptr) {
+    if (s == nullptr) { 
       return !expect_eq_;
     }
     return MatchAndExplain(StringType(s), listener);
@@ -928,11 +928,11 @@ class StrEqualityMatcher {
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because StringView has some interfering non-explicit constructors. 
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
-    const StringType s2(s);
+    const StringType s2(s); 
     const bool eq = case_sensitive_ ? s2 == string_ :
         CaseInsensitiveStringEquals(s2, string_);
     return expect_eq_ == eq;
@@ -970,16 +970,16 @@ class HasSubstrMatcher {
   explicit HasSubstrMatcher(const StringType& substring)
       : substring_(substring) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  bool MatchAndExplain(const internal::StringView& s,
-                       MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
-    // strings.
-    const StringType& str = std::string(s);
-    return MatchAndExplain(str, listener);
-  }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  bool MatchAndExplain(const internal::StringView& s, 
+                       MatchResultListener* listener) const { 
+    // This should fail to compile if StringView is used with wide 
+    // strings. 
+    const StringType& str = std::string(s); 
+    return MatchAndExplain(str, listener); 
+  } 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
   // Accepts pointer types, particularly:
   //   const char*
   //   char*
@@ -987,17 +987,17 @@ class HasSubstrMatcher {
   //   wchar_t*
   template <typename CharType>
   bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != nullptr && MatchAndExplain(StringType(s), listener);
+    return s != nullptr && MatchAndExplain(StringType(s), listener); 
   }
 
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because StringView has some interfering non-explicit constructors. 
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
-    return StringType(s).find(substring_) != StringType::npos;
+    return StringType(s).find(substring_) != StringType::npos; 
   }
 
   // Describes what this matcher matches.
@@ -1024,16 +1024,16 @@ class StartsWithMatcher {
   explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
   }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  bool MatchAndExplain(const internal::StringView& s,
-                       MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
-    // strings.
-    const StringType& str = std::string(s);
-    return MatchAndExplain(str, listener);
-  }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  bool MatchAndExplain(const internal::StringView& s, 
+                       MatchResultListener* listener) const { 
+    // This should fail to compile if StringView is used with wide 
+    // strings. 
+    const StringType& str = std::string(s); 
+    return MatchAndExplain(str, listener); 
+  } 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
   // Accepts pointer types, particularly:
   //   const char*
   //   char*
@@ -1041,13 +1041,13 @@ class StartsWithMatcher {
   //   wchar_t*
   template <typename CharType>
   bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != nullptr && MatchAndExplain(StringType(s), listener);
+    return s != nullptr && MatchAndExplain(StringType(s), listener); 
   }
 
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because StringView has some interfering non-explicit constructors. 
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
@@ -1078,16 +1078,16 @@ class EndsWithMatcher {
  public:
   explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  bool MatchAndExplain(const internal::StringView& s,
-                       MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
-    // strings.
-    const StringType& str = std::string(s);
-    return MatchAndExplain(str, listener);
-  }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  bool MatchAndExplain(const internal::StringView& s, 
+                       MatchResultListener* listener) const { 
+    // This should fail to compile if StringView is used with wide 
+    // strings. 
+    const StringType& str = std::string(s); 
+    return MatchAndExplain(str, listener); 
+  } 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
   // Accepts pointer types, particularly:
   //   const char*
   //   char*
@@ -1095,13 +1095,13 @@ class EndsWithMatcher {
   //   wchar_t*
   template <typename CharType>
   bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != nullptr && MatchAndExplain(StringType(s), listener);
+    return s != nullptr && MatchAndExplain(StringType(s), listener); 
   }
 
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because StringView has some interfering non-explicit constructors. 
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
@@ -1129,19 +1129,19 @@ class EndsWithMatcher {
 // compared don't have to have the same type.
 //
 // The matcher defined here is polymorphic (for example, Eq() can be
-// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
+// used to match a std::tuple<int, short>, a std::tuple<const long&, double>, 
 // etc).  Therefore we use a template type conversion operator in the
 // implementation.
 template <typename D, typename Op>
 class PairMatchBase {
  public:
   template <typename T1, typename T2>
-  operator Matcher<::std::tuple<T1, T2>>() const {
-    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);
+  operator Matcher<::std::tuple<T1, T2>>() const { 
+    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>); 
   }
   template <typename T1, typename T2>
-  operator Matcher<const ::std::tuple<T1, T2>&>() const {
-    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
+  operator Matcher<const ::std::tuple<T1, T2>&>() const { 
+    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>); 
   }
 
  private:
@@ -1152,14 +1152,14 @@ class PairMatchBase {
   template <typename Tuple>
   class Impl : public MatcherInterface<Tuple> {
    public:
-    bool MatchAndExplain(Tuple args,
-                         MatchResultListener* /* listener */) const override {
-      return Op()(::std::get<0>(args), ::std::get<1>(args));
+    bool MatchAndExplain(Tuple args, 
+                         MatchResultListener* /* listener */) const override { 
+      return Op()(::std::get<0>(args), ::std::get<1>(args)); 
     }
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "are " << GetDesc;
     }
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "aren't " << GetDesc;
     }
   };
@@ -1195,21 +1195,21 @@ class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
 // will prevent different instantiations of NotMatcher from sharing
 // the same NotMatcherImpl<T> class.
 template <typename T>
-class NotMatcherImpl : public MatcherInterface<const T&> {
+class NotMatcherImpl : public MatcherInterface<const T&> { 
  public:
   explicit NotMatcherImpl(const Matcher<T>& matcher)
       : matcher_(matcher) {}
 
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(const T& x, 
+                       MatchResultListener* listener) const override { 
     return !matcher_.MatchAndExplain(x, listener);
   }
 
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     matcher_.DescribeNegationTo(os);
   }
 
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     matcher_.DescribeTo(os);
   }
 
@@ -1240,60 +1240,60 @@ class NotMatcher {
 // that will prevent different instantiations of BothOfMatcher from
 // sharing the same BothOfMatcherImpl<T> class.
 template <typename T>
-class AllOfMatcherImpl : public MatcherInterface<const T&> {
+class AllOfMatcherImpl : public MatcherInterface<const T&> { 
  public:
-  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
-      : matchers_(std::move(matchers)) {}
+  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers) 
+      : matchers_(std::move(matchers)) {} 
 
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "(";
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      if (i != 0) *os << ") and (";
-      matchers_[i].DescribeTo(os);
-    }
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      if (i != 0) *os << ") and ("; 
+      matchers_[i].DescribeTo(os); 
+    } 
     *os << ")";
   }
 
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "(";
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      if (i != 0) *os << ") or (";
-      matchers_[i].DescribeNegationTo(os);
-    }
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      if (i != 0) *os << ") or ("; 
+      matchers_[i].DescribeNegationTo(os); 
+    } 
     *os << ")";
   }
 
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(const T& x, 
+                       MatchResultListener* listener) const override { 
     // If either matcher1_ or matcher2_ doesn't match x, we only need
     // to explain why one of them fails.
-    std::string all_match_result;
-
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      StringMatchResultListener slistener;
-      if (matchers_[i].MatchAndExplain(x, &slistener)) {
-        if (all_match_result.empty()) {
-          all_match_result = slistener.str();
-        } else {
-          std::string result = slistener.str();
-          if (!result.empty()) {
-            all_match_result += ", and ";
-            all_match_result += result;
-          }
-        }
-      } else {
-        *listener << slistener.str();
-        return false;
-      }
+    std::string all_match_result; 
+
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      StringMatchResultListener slistener; 
+      if (matchers_[i].MatchAndExplain(x, &slistener)) { 
+        if (all_match_result.empty()) { 
+          all_match_result = slistener.str(); 
+        } else { 
+          std::string result = slistener.str(); 
+          if (!result.empty()) { 
+            all_match_result += ", and "; 
+            all_match_result += result; 
+          } 
+        } 
+      } else { 
+        *listener << slistener.str(); 
+        return false; 
+      } 
     }
 
     // Otherwise we need to explain why *both* of them match.
-    *listener << all_match_result;
+    *listener << all_match_result; 
     return true;
   }
 
  private:
-  const std::vector<Matcher<T> > matchers_;
+  const std::vector<Matcher<T> > matchers_; 
 };
 
 // VariadicMatcher is used for the variadic implementation of
@@ -1304,136 +1304,136 @@ template <template <typename T> class CombiningMatcher, typename... Args>
 class VariadicMatcher {
  public:
   VariadicMatcher(const Args&... matchers)  // NOLINT
-      : matchers_(matchers...) {
-    static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");
-  }
-
-  VariadicMatcher(const VariadicMatcher&) = default;
-  VariadicMatcher& operator=(const VariadicMatcher&) = delete;
+      : matchers_(matchers...) { 
+    static_assert(sizeof...(Args) > 0, "Must have at least one matcher."); 
+  } 
 
+  VariadicMatcher(const VariadicMatcher&) = default; 
+  VariadicMatcher& operator=(const VariadicMatcher&) = delete; 
+ 
   // This template type conversion operator allows an
   // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
   // all of the provided matchers (Matcher1, Matcher2, ...) can match.
   template <typename T>
   operator Matcher<T>() const {
-    std::vector<Matcher<T> > values;
-    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
-    return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
+    std::vector<Matcher<T> > values; 
+    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>()); 
+    return Matcher<T>(new CombiningMatcher<T>(std::move(values))); 
   }
 
  private:
-  template <typename T, size_t I>
-  void CreateVariadicMatcher(std::vector<Matcher<T> >* values,
-                             std::integral_constant<size_t, I>) const {
-    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
-    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
-  }
-
-  template <typename T>
-  void CreateVariadicMatcher(
-      std::vector<Matcher<T> >*,
-      std::integral_constant<size_t, sizeof...(Args)>) const {}
-
-  std::tuple<Args...> matchers_;
+  template <typename T, size_t I> 
+  void CreateVariadicMatcher(std::vector<Matcher<T> >* values, 
+                             std::integral_constant<size_t, I>) const { 
+    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_))); 
+    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>()); 
+  } 
+
+  template <typename T> 
+  void CreateVariadicMatcher( 
+      std::vector<Matcher<T> >*, 
+      std::integral_constant<size_t, sizeof...(Args)>) const {} 
+
+  std::tuple<Args...> matchers_; 
 };
 
 template <typename... Args>
-using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
+using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>; 
 
 // Implements the AnyOf(m1, m2) matcher for a particular argument type
 // T.  We do not nest it inside the AnyOfMatcher class template, as
 // that will prevent different instantiations of AnyOfMatcher from
 // sharing the same EitherOfMatcherImpl<T> class.
 template <typename T>
-class AnyOfMatcherImpl : public MatcherInterface<const T&> {
+class AnyOfMatcherImpl : public MatcherInterface<const T&> { 
  public:
-  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
-      : matchers_(std::move(matchers)) {}
+  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers) 
+      : matchers_(std::move(matchers)) {} 
 
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "(";
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      if (i != 0) *os << ") or (";
-      matchers_[i].DescribeTo(os);
-    }
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      if (i != 0) *os << ") or ("; 
+      matchers_[i].DescribeTo(os); 
+    } 
     *os << ")";
   }
 
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "(";
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      if (i != 0) *os << ") and (";
-      matchers_[i].DescribeNegationTo(os);
-    }
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      if (i != 0) *os << ") and ("; 
+      matchers_[i].DescribeNegationTo(os); 
+    } 
     *os << ")";
   }
 
-  bool MatchAndExplain(const T& x,
-                       MatchResultListener* listener) const override {
-    std::string no_match_result;
-
+  bool MatchAndExplain(const T& x, 
+                       MatchResultListener* listener) const override { 
+    std::string no_match_result; 
+ 
     // If either matcher1_ or matcher2_ matches x, we just need to
     // explain why *one* of them matches.
-    for (size_t i = 0; i < matchers_.size(); ++i) {
-      StringMatchResultListener slistener;
-      if (matchers_[i].MatchAndExplain(x, &slistener)) {
-        *listener << slistener.str();
-        return true;
-      } else {
-        if (no_match_result.empty()) {
-          no_match_result = slistener.str();
-        } else {
-          std::string result = slistener.str();
-          if (!result.empty()) {
-            no_match_result += ", and ";
-            no_match_result += result;
-          }
-        }
-      }
+    for (size_t i = 0; i < matchers_.size(); ++i) { 
+      StringMatchResultListener slistener; 
+      if (matchers_[i].MatchAndExplain(x, &slistener)) { 
+        *listener << slistener.str(); 
+        return true; 
+      } else { 
+        if (no_match_result.empty()) { 
+          no_match_result = slistener.str(); 
+        } else { 
+          std::string result = slistener.str(); 
+          if (!result.empty()) { 
+            no_match_result += ", and "; 
+            no_match_result += result; 
+          } 
+        } 
+      } 
     }
 
     // Otherwise we need to explain why *both* of them fail.
-    *listener << no_match_result;
+    *listener << no_match_result; 
     return false;
   }
 
  private:
-  const std::vector<Matcher<T> > matchers_;
+  const std::vector<Matcher<T> > matchers_; 
 };
 
 // AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
 template <typename... Args>
-using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
+using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>; 
 
-// Wrapper for implementation of Any/AllOfArray().
-template <template <class> class MatcherImpl, typename T>
-class SomeOfArrayMatcher {
+// Wrapper for implementation of Any/AllOfArray(). 
+template <template <class> class MatcherImpl, typename T> 
+class SomeOfArrayMatcher { 
  public:
-  // Constructs the matcher from a sequence of element values or
-  // element matchers.
-  template <typename Iter>
-  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
-
-  template <typename U>
-  operator Matcher<U>() const {  // NOLINT
-    using RawU = typename std::decay<U>::type;
-    std::vector<Matcher<RawU>> matchers;
-    for (const auto& matcher : matchers_) {
-      matchers.push_back(MatcherCast<RawU>(matcher));
-    }
-    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
+  // Constructs the matcher from a sequence of element values or 
+  // element matchers. 
+  template <typename Iter> 
+  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {} 
+
+  template <typename U> 
+  operator Matcher<U>() const {  // NOLINT 
+    using RawU = typename std::decay<U>::type; 
+    std::vector<Matcher<RawU>> matchers; 
+    for (const auto& matcher : matchers_) { 
+      matchers.push_back(MatcherCast<RawU>(matcher)); 
+    } 
+    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers))); 
   }
 
  private:
-  const ::std::vector<T> matchers_;
+  const ::std::vector<T> matchers_; 
 };
 
-template <typename T>
-using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;
-
-template <typename T>
-using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;
-
+template <typename T> 
+using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>; 
+ 
+template <typename T> 
+using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>; 
+ 
 // Used for implementing Truly(pred), which turns a predicate into a
 // matcher.
 template <typename Predicate>
@@ -1447,7 +1447,7 @@ class TrulyMatcher {
   // interested in the address of the argument.
   template <typename T>
   bool MatchAndExplain(T& x,  // NOLINT
-                       MatchResultListener* listener) const {
+                       MatchResultListener* listener) const { 
     // Without the if-statement, MSVC sometimes warns about converting
     // a value to bool (warning 4800).
     //
@@ -1456,7 +1456,7 @@ class TrulyMatcher {
     // having no operator!().
     if (predicate_(x))
       return true;
-    *listener << "didn't satisfy the given predicate";
+    *listener << "didn't satisfy the given predicate"; 
     return false;
   }
 
@@ -1513,7 +1513,7 @@ class MatcherAsPredicate {
 template <typename M>
 class PredicateFormatterFromMatcher {
  public:
-  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {} 
 
   // This template () operator allows a PredicateFormatterFromMatcher
   // object to act as a predicate-formatter suitable for using with
@@ -1532,24 +1532,24 @@ class PredicateFormatterFromMatcher {
     // We don't write MatcherCast<const T&> either, as that allows
     // potentially unsafe downcasting of the matcher argument.
     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
-
-    // The expected path here is that the matcher should match (i.e. that most
-    // tests pass) so optimize for this case.
-    if (matcher.Matches(x)) {
+ 
+    // The expected path here is that the matcher should match (i.e. that most 
+    // tests pass) so optimize for this case. 
+    if (matcher.Matches(x)) { 
       return AssertionSuccess();
-    }
+    } 
 
     ::std::stringstream ss;
     ss << "Value of: " << value_text << "\n"
        << "Expected: ";
     matcher.DescribeTo(&ss);
-
-    // Rerun the matcher to "PrintAndExplain" the failure.
-    StringMatchResultListener listener;
-    if (MatchPrintAndExplain(x, matcher, &listener)) {
-      ss << "\n  The matcher failed on the initial attempt; but passed when "
-            "rerun to generate the explanation.";
-    }
+ 
+    // Rerun the matcher to "PrintAndExplain" the failure. 
+    StringMatchResultListener listener; 
+    if (MatchPrintAndExplain(x, matcher, &listener)) { 
+      ss << "\n  The matcher failed on the initial attempt; but passed when " 
+            "rerun to generate the explanation."; 
+    } 
     ss << "\n  Actual: " << listener.str();
     return AssertionFailure() << ss.str();
   }
@@ -1565,25 +1565,25 @@ class PredicateFormatterFromMatcher {
 template <typename M>
 inline PredicateFormatterFromMatcher<M>
 MakePredicateFormatterFromMatcher(M matcher) {
-  return PredicateFormatterFromMatcher<M>(std::move(matcher));
-}
-
-// Implements the polymorphic IsNan() matcher, which matches any floating type
-// value that is Nan.
-class IsNanMatcher {
- public:
-  template <typename FloatType>
-  bool MatchAndExplain(const FloatType& f,
-                       MatchResultListener* /* listener */) const {
-    return (::std::isnan)(f);
-  }
-
-  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "isn't NaN";
-  }
-};
-
+  return PredicateFormatterFromMatcher<M>(std::move(matcher)); 
+}
+
+// Implements the polymorphic IsNan() matcher, which matches any floating type 
+// value that is Nan. 
+class IsNanMatcher { 
+ public: 
+  template <typename FloatType> 
+  bool MatchAndExplain(const FloatType& f, 
+                       MatchResultListener* /* listener */) const { 
+    return (::std::isnan)(f); 
+  } 
+ 
+  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; } 
+  void DescribeNegationTo(::std::ostream* os) const { 
+    *os << "isn't NaN"; 
+  } 
+}; 
+ 
 // Implements the polymorphic floating point equality matcher, which matches
 // two float values using ULP-based approximation or, optionally, a
 // user-specified epsilon.  The template is meant to be instantiated with
@@ -1622,8 +1622,8 @@ class FloatingEqMatcher {
           nan_eq_nan_(nan_eq_nan),
           max_abs_error_(max_abs_error) {}
 
-    bool MatchAndExplain(T value,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(T value, 
+                         MatchResultListener* listener) const override { 
       const FloatingPoint<FloatType> actual(value), expected(expected_);
 
       // Compares NaNs first, if nan_eq_nan_ is true.
@@ -1644,7 +1644,7 @@ class FloatingEqMatcher {
         }
 
         const FloatType diff = value - expected_;
-        if (::std::fabs(diff) <= max_abs_error_) {
+        if (::std::fabs(diff) <= max_abs_error_) { 
           return true;
         }
 
@@ -1657,7 +1657,7 @@ class FloatingEqMatcher {
       }
     }
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       // os->precision() returns the previously set precision, which we
       // store to restore the ostream to its original configuration
       // after outputting.
@@ -1678,7 +1678,7 @@ class FloatingEqMatcher {
       os->precision(old_precision);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       // As before, get original precision.
       const ::std::streamsize old_precision = os->precision(
           ::std::numeric_limits<FloatType>::digits10 + 2);
@@ -1734,82 +1734,82 @@ class FloatingEqMatcher {
   const FloatType max_abs_error_;
 };
 
-// A 2-tuple ("binary") wrapper around FloatingEqMatcher:
-// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)
-// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)
-// against y. The former implements "Eq", the latter "Near". At present, there
-// is no version that compares NaNs as equal.
-template <typename FloatType>
-class FloatingEq2Matcher {
- public:
-  FloatingEq2Matcher() { Init(-1, false); }
-
-  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
-
-  explicit FloatingEq2Matcher(FloatType max_abs_error) {
-    Init(max_abs_error, false);
-  }
-
-  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {
-    Init(max_abs_error, nan_eq_nan);
-  }
-
-  template <typename T1, typename T2>
-  operator Matcher<::std::tuple<T1, T2>>() const {
-    return MakeMatcher(
-        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
-  }
-  template <typename T1, typename T2>
-  operator Matcher<const ::std::tuple<T1, T2>&>() const {
-    return MakeMatcher(
-        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));
-  }
-
- private:
-  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
-    return os << "an almost-equal pair";
-  }
-
-  template <typename Tuple>
-  class Impl : public MatcherInterface<Tuple> {
-   public:
-    Impl(FloatType max_abs_error, bool nan_eq_nan) :
-        max_abs_error_(max_abs_error),
-        nan_eq_nan_(nan_eq_nan) {}
-
-    bool MatchAndExplain(Tuple args,
-                         MatchResultListener* listener) const override {
-      if (max_abs_error_ == -1) {
-        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
-        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
-            ::std::get<1>(args), listener);
-      } else {
-        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
-                                        max_abs_error_);
-        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
-            ::std::get<1>(args), listener);
-      }
-    }
-    void DescribeTo(::std::ostream* os) const override {
-      *os << "are " << GetDesc;
-    }
-    void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "aren't " << GetDesc;
-    }
-
-   private:
-    FloatType max_abs_error_;
-    const bool nan_eq_nan_;
-  };
-
-  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {
-    max_abs_error_ = max_abs_error_val;
-    nan_eq_nan_ = nan_eq_nan_val;
-  }
-  FloatType max_abs_error_;
-  bool nan_eq_nan_;
-};
-
+// A 2-tuple ("binary") wrapper around FloatingEqMatcher: 
+// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false) 
+// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e) 
+// against y. The former implements "Eq", the latter "Near". At present, there 
+// is no version that compares NaNs as equal. 
+template <typename FloatType> 
+class FloatingEq2Matcher { 
+ public: 
+  FloatingEq2Matcher() { Init(-1, false); } 
+ 
+  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); } 
+ 
+  explicit FloatingEq2Matcher(FloatType max_abs_error) { 
+    Init(max_abs_error, false); 
+  } 
+ 
+  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) { 
+    Init(max_abs_error, nan_eq_nan); 
+  } 
+ 
+  template <typename T1, typename T2> 
+  operator Matcher<::std::tuple<T1, T2>>() const { 
+    return MakeMatcher( 
+        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_)); 
+  } 
+  template <typename T1, typename T2> 
+  operator Matcher<const ::std::tuple<T1, T2>&>() const { 
+    return MakeMatcher( 
+        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_)); 
+  } 
+ 
+ private: 
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT 
+    return os << "an almost-equal pair"; 
+  } 
+ 
+  template <typename Tuple> 
+  class Impl : public MatcherInterface<Tuple> { 
+   public: 
+    Impl(FloatType max_abs_error, bool nan_eq_nan) : 
+        max_abs_error_(max_abs_error), 
+        nan_eq_nan_(nan_eq_nan) {} 
+ 
+    bool MatchAndExplain(Tuple args, 
+                         MatchResultListener* listener) const override { 
+      if (max_abs_error_ == -1) { 
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_); 
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( 
+            ::std::get<1>(args), listener); 
+      } else { 
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_, 
+                                        max_abs_error_); 
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain( 
+            ::std::get<1>(args), listener); 
+      } 
+    } 
+    void DescribeTo(::std::ostream* os) const override { 
+      *os << "are " << GetDesc; 
+    } 
+    void DescribeNegationTo(::std::ostream* os) const override { 
+      *os << "aren't " << GetDesc; 
+    } 
+ 
+   private: 
+    FloatType max_abs_error_; 
+    const bool nan_eq_nan_; 
+  }; 
+ 
+  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) { 
+    max_abs_error_ = max_abs_error_val; 
+    nan_eq_nan_ = nan_eq_nan_val; 
+  } 
+  FloatType max_abs_error_; 
+  bool nan_eq_nan_; 
+}; 
+ 
 // Implements the Pointee(m) matcher for matching a pointer whose
 // pointee matches matcher m.  The pointer can be either raw or smart.
 template <typename InnerMatcher>
@@ -1827,7 +1827,7 @@ class PointeeMatcher {
   // enough for implementing the DescribeTo() method of Pointee().
   template <typename Pointer>
   operator Matcher<Pointer>() const {
-    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
+    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_)); 
   }
 
  private:
@@ -1835,26 +1835,26 @@ class PointeeMatcher {
   template <typename Pointer>
   class Impl : public MatcherInterface<Pointer> {
    public:
-    using Pointee =
-        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
-            Pointer)>::element_type;
+    using Pointee = 
+        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( 
+            Pointer)>::element_type; 
 
     explicit Impl(const InnerMatcher& matcher)
         : matcher_(MatcherCast<const Pointee&>(matcher)) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "points to a value that ";
       matcher_.DescribeTo(os);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "does not point to a value that ";
       matcher_.DescribeTo(os);
     }
 
-    bool MatchAndExplain(Pointer pointer,
-                         MatchResultListener* listener) const override {
-      if (GetRawPointer(pointer) == nullptr) return false;
+    bool MatchAndExplain(Pointer pointer, 
+                         MatchResultListener* listener) const override { 
+      if (GetRawPointer(pointer) == nullptr) return false; 
 
       *listener << "which points to ";
       return MatchPrintAndExplain(*pointer, matcher_, listener);
@@ -1867,65 +1867,65 @@ class PointeeMatcher {
   const InnerMatcher matcher_;
 };
 
-// Implements the Pointer(m) matcher
-// Implements the Pointer(m) matcher for matching a pointer that matches matcher
-// m.  The pointer can be either raw or smart, and will match `m` against the
-// raw pointer.
-template <typename InnerMatcher>
-class PointerMatcher {
- public:
-  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
-
-  // This type conversion operator template allows Pointer(m) to be
-  // used as a matcher for any pointer type whose pointer type is
-  // compatible with the inner matcher, where type PointerType can be
-  // either a raw pointer or a smart pointer.
-  //
-  // The reason we do this instead of relying on
-  // MakePolymorphicMatcher() is that the latter is not flexible
-  // enough for implementing the DescribeTo() method of Pointer().
-  template <typename PointerType>
-  operator Matcher<PointerType>() const {  // NOLINT
-    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
-  }
-
- private:
-  // The monomorphic implementation that works for a particular pointer type.
-  template <typename PointerType>
-  class Impl : public MatcherInterface<PointerType> {
-   public:
-    using Pointer =
-        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
-            PointerType)>::element_type*;
-
-    explicit Impl(const InnerMatcher& matcher)
-        : matcher_(MatcherCast<Pointer>(matcher)) {}
-
-    void DescribeTo(::std::ostream* os) const override {
-      *os << "is a pointer that ";
-      matcher_.DescribeTo(os);
-    }
-
-    void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "is not a pointer that ";
-      matcher_.DescribeTo(os);
-    }
-
-    bool MatchAndExplain(PointerType pointer,
-                         MatchResultListener* listener) const override {
-      *listener << "which is a pointer that ";
-      Pointer p = GetRawPointer(pointer);
-      return MatchPrintAndExplain(p, matcher_, listener);
-    }
-
-   private:
-    Matcher<Pointer> matcher_;
-  };
-
-  const InnerMatcher matcher_;
-};
-
-#if GTEST_HAS_RTTI
+// Implements the Pointer(m) matcher 
+// Implements the Pointer(m) matcher for matching a pointer that matches matcher 
+// m.  The pointer can be either raw or smart, and will match `m` against the 
+// raw pointer. 
+template <typename InnerMatcher> 
+class PointerMatcher { 
+ public: 
+  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {} 
+ 
+  // This type conversion operator template allows Pointer(m) to be 
+  // used as a matcher for any pointer type whose pointer type is 
+  // compatible with the inner matcher, where type PointerType can be 
+  // either a raw pointer or a smart pointer. 
+  // 
+  // The reason we do this instead of relying on 
+  // MakePolymorphicMatcher() is that the latter is not flexible 
+  // enough for implementing the DescribeTo() method of Pointer(). 
+  template <typename PointerType> 
+  operator Matcher<PointerType>() const {  // NOLINT 
+    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_)); 
+  } 
+ 
+ private: 
+  // The monomorphic implementation that works for a particular pointer type. 
+  template <typename PointerType> 
+  class Impl : public MatcherInterface<PointerType> { 
+   public: 
+    using Pointer = 
+        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_( 
+            PointerType)>::element_type*; 
+ 
+    explicit Impl(const InnerMatcher& matcher) 
+        : matcher_(MatcherCast<Pointer>(matcher)) {} 
+ 
+    void DescribeTo(::std::ostream* os) const override { 
+      *os << "is a pointer that "; 
+      matcher_.DescribeTo(os); 
+    } 
+ 
+    void DescribeNegationTo(::std::ostream* os) const override { 
+      *os << "is not a pointer that "; 
+      matcher_.DescribeTo(os); 
+    } 
+ 
+    bool MatchAndExplain(PointerType pointer, 
+                         MatchResultListener* listener) const override { 
+      *listener << "which is a pointer that "; 
+      Pointer p = GetRawPointer(pointer); 
+      return MatchPrintAndExplain(p, matcher_, listener); 
+    } 
+ 
+   private: 
+    Matcher<Pointer> matcher_; 
+  }; 
+ 
+  const InnerMatcher matcher_; 
+}; 
+ 
+#if GTEST_HAS_RTTI 
 // Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
 // reference that matches inner_matcher when dynamic_cast<T> is applied.
 // The result of dynamic_cast<To> is forwarded to the inner matcher.
@@ -1951,7 +1951,7 @@ class WhenDynamicCastToMatcherBase {
  protected:
   const Matcher<To> matcher_;
 
-  static std::string GetToName() {
+  static std::string GetToName() { 
     return GetTypeName<To>();
   }
 
@@ -1988,14 +1988,14 @@ class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
   bool MatchAndExplain(From& from, MatchResultListener* listener) const {
     // We don't want an std::bad_cast here, so do the cast with pointers.
     To* to = dynamic_cast<To*>(&from);
-    if (to == nullptr) {
+    if (to == nullptr) { 
       *listener << "which cannot be dynamic_cast to " << this->GetToName();
       return false;
     }
     return MatchPrintAndExplain(*to, this->matcher_, listener);
   }
 };
-#endif  // GTEST_HAS_RTTI
+#endif  // GTEST_HAS_RTTI 
 
 // Implements the Field() matcher for matching a field (i.e. member
 // variable) of an object.
@@ -2004,126 +2004,126 @@ class FieldMatcher {
  public:
   FieldMatcher(FieldType Class::*field,
                const Matcher<const FieldType&>& matcher)
-      : field_(field), matcher_(matcher), whose_field_("whose given field ") {}
-
-  FieldMatcher(const std::string& field_name, FieldType Class::*field,
-               const Matcher<const FieldType&>& matcher)
-      : field_(field),
-        matcher_(matcher),
-        whose_field_("whose field `" + field_name + "` ") {}
-
+      : field_(field), matcher_(matcher), whose_field_("whose given field ") {} 
+
+  FieldMatcher(const std::string& field_name, FieldType Class::*field, 
+               const Matcher<const FieldType&>& matcher) 
+      : field_(field), 
+        matcher_(matcher), 
+        whose_field_("whose field `" + field_name + "` ") {} 
+ 
   void DescribeTo(::std::ostream* os) const {
-    *os << "is an object " << whose_field_;
+    *os << "is an object " << whose_field_; 
     matcher_.DescribeTo(os);
   }
 
   void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object " << whose_field_;
+    *os << "is an object " << whose_field_; 
     matcher_.DescribeNegationTo(os);
   }
 
   template <typename T>
   bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
-    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for
-    // a compiler bug, and can now be removed.
+    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for 
+    // a compiler bug, and can now be removed. 
     return MatchAndExplainImpl(
-        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(), 
         value, listener);
   }
 
  private:
-  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
-                           const Class& obj,
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, 
+                           const Class& obj, 
                            MatchResultListener* listener) const {
-    *listener << whose_field_ << "is ";
+    *listener << whose_field_ << "is "; 
     return MatchPrintAndExplain(obj.*field_, matcher_, listener);
   }
 
-  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, 
                            MatchResultListener* listener) const {
-    if (p == nullptr) return false;
+    if (p == nullptr) return false; 
 
     *listener << "which points to an object ";
     // Since *p has a field, it must be a class/struct/union type and
     // thus cannot be a pointer.  Therefore we pass false_type() as
     // the first argument.
-    return MatchAndExplainImpl(std::false_type(), *p, listener);
+    return MatchAndExplainImpl(std::false_type(), *p, listener); 
   }
 
   const FieldType Class::*field_;
   const Matcher<const FieldType&> matcher_;
 
-  // Contains either "whose given field " if the name of the field is unknown
-  // or "whose field `name_of_field` " if the name is known.
-  const std::string whose_field_;
+  // Contains either "whose given field " if the name of the field is unknown 
+  // or "whose field `name_of_field` " if the name is known. 
+  const std::string whose_field_; 
 };
 
 // Implements the Property() matcher for matching a property
 // (i.e. return value of a getter method) of an object.
-//
-// Property is a const-qualified member function of Class returning
-// PropertyType.
-template <typename Class, typename PropertyType, typename Property>
+// 
+// Property is a const-qualified member function of Class returning 
+// PropertyType. 
+template <typename Class, typename PropertyType, typename Property> 
 class PropertyMatcher {
  public:
-  typedef const PropertyType& RefToConstProperty;
-
-  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)
-      : property_(property),
-        matcher_(matcher),
-        whose_property_("whose given property ") {}
-
-  PropertyMatcher(const std::string& property_name, Property property,
+  typedef const PropertyType& RefToConstProperty; 
+
+  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher) 
+      : property_(property), 
+        matcher_(matcher), 
+        whose_property_("whose given property ") {} 
+ 
+  PropertyMatcher(const std::string& property_name, Property property, 
                   const Matcher<RefToConstProperty>& matcher)
-      : property_(property),
-        matcher_(matcher),
-        whose_property_("whose property `" + property_name + "` ") {}
+      : property_(property), 
+        matcher_(matcher), 
+        whose_property_("whose property `" + property_name + "` ") {} 
 
   void DescribeTo(::std::ostream* os) const {
-    *os << "is an object " << whose_property_;
+    *os << "is an object " << whose_property_; 
     matcher_.DescribeTo(os);
   }
 
   void DescribeNegationTo(::std::ostream* os) const {
-    *os << "is an object " << whose_property_;
+    *os << "is an object " << whose_property_; 
     matcher_.DescribeNegationTo(os);
   }
 
   template <typename T>
   bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
     return MatchAndExplainImpl(
-        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(), 
         value, listener);
   }
 
  private:
-  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
-                           const Class& obj,
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */, 
+                           const Class& obj, 
                            MatchResultListener* listener) const {
-    *listener << whose_property_ << "is ";
+    *listener << whose_property_ << "is "; 
     // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
     // which takes a non-const reference as argument.
     RefToConstProperty result = (obj.*property_)();
     return MatchPrintAndExplain(result, matcher_, listener);
   }
 
-  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p, 
                            MatchResultListener* listener) const {
-    if (p == nullptr) return false;
+    if (p == nullptr) return false; 
 
     *listener << "which points to an object ";
     // Since *p has a property method, it must be a class/struct/union
     // type and thus cannot be a pointer.  Therefore we pass
     // false_type() as the first argument.
-    return MatchAndExplainImpl(std::false_type(), *p, listener);
+    return MatchAndExplainImpl(std::false_type(), *p, listener); 
   }
 
-  Property property_;
+  Property property_; 
   const Matcher<RefToConstProperty> matcher_;
 
-  // Contains either "whose given property " if the name of the property is
-  // unknown or "whose property `name_of_property` " if the name is known.
-  const std::string whose_property_;
+  // Contains either "whose given property " if the name of the property is 
+  // unknown or "whose property `name_of_property` " if the name is known. 
+  const std::string whose_property_; 
 };
 
 // Type traits specifying various features of different functors for ResultOf.
@@ -2133,11 +2133,11 @@ struct CallableTraits {
   typedef Functor StorageType;
 
   static void CheckIsValid(Functor /* functor */) {}
-
+ 
   template <typename T>
-  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
-    return f(arg);
-  }
+  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) { 
+    return f(arg); 
+  } 
 };
 
 // Specialization for function pointers.
@@ -2147,7 +2147,7 @@ struct CallableTraits<ResType(*)(ArgType)> {
   typedef ResType(*StorageType)(ArgType);
 
   static void CheckIsValid(ResType(*f)(ArgType)) {
-    GTEST_CHECK_(f != nullptr)
+    GTEST_CHECK_(f != nullptr) 
         << "NULL function pointer is passed into ResultOf().";
   }
   template <typename T>
@@ -2158,17 +2158,17 @@ struct CallableTraits<ResType(*)(ArgType)> {
 
 // Implements the ResultOf() matcher for matching a return value of a
 // unary function of an object.
-template <typename Callable, typename InnerMatcher>
+template <typename Callable, typename InnerMatcher> 
 class ResultOfMatcher {
  public:
-  ResultOfMatcher(Callable callable, InnerMatcher matcher)
-      : callable_(std::move(callable)), matcher_(std::move(matcher)) {
+  ResultOfMatcher(Callable callable, InnerMatcher matcher) 
+      : callable_(std::move(callable)), matcher_(std::move(matcher)) { 
     CallableTraits<Callable>::CheckIsValid(callable_);
   }
 
   template <typename T>
   operator Matcher<T>() const {
-    return Matcher<T>(new Impl<const T&>(callable_, matcher_));
+    return Matcher<T>(new Impl<const T&>(callable_, matcher_)); 
   }
 
  private:
@@ -2176,30 +2176,30 @@ class ResultOfMatcher {
 
   template <typename T>
   class Impl : public MatcherInterface<T> {
-    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
-        std::declval<CallableStorageType>(), std::declval<T>()));
-
+    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>( 
+        std::declval<CallableStorageType>(), std::declval<T>())); 
+ 
    public:
-    template <typename M>
-    Impl(const CallableStorageType& callable, const M& matcher)
-        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {}
+    template <typename M> 
+    Impl(const CallableStorageType& callable, const M& matcher) 
+        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {} 
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "is mapped by the given callable to a value that ";
       matcher_.DescribeTo(os);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "is mapped by the given callable to a value that ";
       matcher_.DescribeNegationTo(os);
     }
 
-    bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
+    bool MatchAndExplain(T obj, MatchResultListener* listener) const override { 
       *listener << "which is mapped by the given callable to ";
-      // Cannot pass the return value directly to MatchPrintAndExplain, which
-      // takes a non-const reference as argument.
-      // Also, specifying template argument explicitly is needed because T could
-      // be a non-const reference (e.g. Matcher<Uncopyable&>).
+      // Cannot pass the return value directly to MatchPrintAndExplain, which 
+      // takes a non-const reference as argument. 
+      // Also, specifying template argument explicitly is needed because T could 
+      // be a non-const reference (e.g. Matcher<Uncopyable&>). 
       ResultType result =
           CallableTraits<Callable>::template Invoke<T>(callable_, obj);
       return MatchPrintAndExplain(result, matcher_, listener);
@@ -2207,16 +2207,16 @@ class ResultOfMatcher {
 
    private:
     // Functors often define operator() as non-const method even though
-    // they are actually stateless. But we need to use them even when
+    // they are actually stateless. But we need to use them even when 
     // 'this' is a const pointer. It's the user's responsibility not to
-    // use stateful callables with ResultOf(), which doesn't guarantee
+    // use stateful callables with ResultOf(), which doesn't guarantee 
     // how many times the callable will be invoked.
     mutable CallableStorageType callable_;
     const Matcher<ResultType> matcher_;
   };  // class Impl
 
   const CallableStorageType callable_;
-  const InnerMatcher matcher_;
+  const InnerMatcher matcher_; 
 };
 
 // Implements a matcher that checks the size of an STL-style container.
@@ -2229,27 +2229,27 @@ class SizeIsMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    return Matcher<Container>(new Impl<const Container&>(size_matcher_));
+    return Matcher<Container>(new Impl<const Container&>(size_matcher_)); 
   }
 
   template <typename Container>
   class Impl : public MatcherInterface<Container> {
    public:
-    using SizeType = decltype(std::declval<Container>().size());
+    using SizeType = decltype(std::declval<Container>().size()); 
     explicit Impl(const SizeMatcher& size_matcher)
         : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "size ";
       size_matcher_.DescribeTo(os);
     }
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "size ";
       size_matcher_.DescribeNegationTo(os);
     }
 
-    bool MatchAndExplain(Container container,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(Container container, 
+                         MatchResultListener* listener) const override { 
       SizeType size = container.size();
       StringMatchResultListener size_listener;
       const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
@@ -2277,7 +2277,7 @@ class BeginEndDistanceIsMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    return Matcher<Container>(new Impl<const Container&>(distance_matcher_));
+    return Matcher<Container>(new Impl<const Container&>(distance_matcher_)); 
   }
 
   template <typename Container>
@@ -2291,17 +2291,17 @@ class BeginEndDistanceIsMatcher {
     explicit Impl(const DistanceMatcher& distance_matcher)
         : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "distance between begin() and end() ";
       distance_matcher_.DescribeTo(os);
     }
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "distance between begin() and end() ";
       distance_matcher_.DescribeNegationTo(os);
     }
 
-    bool MatchAndExplain(Container container,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(Container container, 
+                         MatchResultListener* listener) const override { 
       using std::begin;
       using std::end;
       DistanceType distance = std::distance(begin(container), end(container));
@@ -2339,15 +2339,15 @@ class ContainerEqMatcher {
   typedef typename View::type StlContainer;
   typedef typename View::const_reference StlContainerReference;
 
-  static_assert(!std::is_const<Container>::value,
-                "Container type must not be const");
-  static_assert(!std::is_reference<Container>::value,
-                "Container type must not be a reference");
-
+  static_assert(!std::is_const<Container>::value, 
+                "Container type must not be const"); 
+  static_assert(!std::is_reference<Container>::value, 
+                "Container type must not be a reference"); 
+ 
   // We make a copy of expected in case the elements in it are modified
   // after this matcher is created.
   explicit ContainerEqMatcher(const Container& expected)
-      : expected_(View::Copy(expected)) {}
+      : expected_(View::Copy(expected)) {} 
 
   void DescribeTo(::std::ostream* os) const {
     *os << "equals ";
@@ -2361,8 +2361,8 @@ class ContainerEqMatcher {
   template <typename LhsContainer>
   bool MatchAndExplain(const LhsContainer& lhs,
                        MatchResultListener* listener) const {
-    typedef internal::StlContainerView<
-        typename std::remove_const<LhsContainer>::type>
+    typedef internal::StlContainerView< 
+        typename std::remove_const<LhsContainer>::type> 
         LhsView;
     typedef typename LhsView::type LhsStlContainer;
     StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
@@ -2370,7 +2370,7 @@ class ContainerEqMatcher {
       return true;
 
     ::std::ostream* const os = listener->stream();
-    if (os != nullptr) {
+    if (os != nullptr) { 
       // Something is different. Check for extra values first.
       bool printed_header = false;
       for (typename LhsStlContainer::const_iterator it =
@@ -2448,18 +2448,18 @@ class WhenSortedByMatcher {
     Impl(const Comparator& comparator, const ContainerMatcher& matcher)
         : comparator_(comparator), matcher_(matcher) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "(when sorted) ";
       matcher_.DescribeTo(os);
     }
 
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "(when sorted) ";
       matcher_.DescribeNegationTo(os);
     }
 
-    bool MatchAndExplain(LhsContainer lhs,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(LhsContainer lhs, 
+                         MatchResultListener* listener) const override { 
       LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
       ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
                                                lhs_stl_container.end());
@@ -2496,38 +2496,38 @@ class WhenSortedByMatcher {
 };
 
 // Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
-// must be able to be safely cast to Matcher<std::tuple<const T1&, const
+// must be able to be safely cast to Matcher<std::tuple<const T1&, const 
 // T2&> >, where T1 and T2 are the types of elements in the LHS
 // container and the RHS container respectively.
 template <typename TupleMatcher, typename RhsContainer>
 class PointwiseMatcher {
-  GTEST_COMPILE_ASSERT_(
-      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
-      use_UnorderedPointwise_with_hash_tables);
-
+  GTEST_COMPILE_ASSERT_( 
+      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value, 
+      use_UnorderedPointwise_with_hash_tables); 
+ 
  public:
   typedef internal::StlContainerView<RhsContainer> RhsView;
   typedef typename RhsView::type RhsStlContainer;
   typedef typename RhsStlContainer::value_type RhsValue;
 
-  static_assert(!std::is_const<RhsContainer>::value,
-                "RhsContainer type must not be const");
-  static_assert(!std::is_reference<RhsContainer>::value,
-                "RhsContainer type must not be a reference");
-
+  static_assert(!std::is_const<RhsContainer>::value, 
+                "RhsContainer type must not be const"); 
+  static_assert(!std::is_reference<RhsContainer>::value, 
+                "RhsContainer type must not be a reference"); 
+ 
   // Like ContainerEq, we make a copy of rhs in case the elements in
   // it are modified after this matcher is created.
   PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
-      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}
+      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {} 
 
   template <typename LhsContainer>
   operator Matcher<LhsContainer>() const {
-    GTEST_COMPILE_ASSERT_(
-        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
-        use_UnorderedPointwise_with_hash_tables);
-
-    return Matcher<LhsContainer>(
-        new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
+    GTEST_COMPILE_ASSERT_( 
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value, 
+        use_UnorderedPointwise_with_hash_tables); 
+ 
+    return Matcher<LhsContainer>( 
+        new Impl<const LhsContainer&>(tuple_matcher_, rhs_)); 
   }
 
   template <typename LhsContainer>
@@ -2542,21 +2542,21 @@ class PointwiseMatcher {
     // reference, as they may be expensive to copy.  We must use tuple
     // instead of pair here, as a pair cannot hold references (C++ 98,
     // 20.2.2 [lib.pairs]).
-    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
+    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg; 
 
     Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
         // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
         : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
           rhs_(rhs) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "contains " << rhs_.size()
           << " values, where each value and its corresponding value in ";
       UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
       *os << " ";
       mono_tuple_matcher_.DescribeTo(os);
     }
-    void DescribeNegationTo(::std::ostream* os) const override {
+    void DescribeNegationTo(::std::ostream* os) const override { 
       *os << "doesn't contain exactly " << rhs_.size()
           << " values, or contains a value x at some index i"
           << " where x and the i-th value of ";
@@ -2565,8 +2565,8 @@ class PointwiseMatcher {
       mono_tuple_matcher_.DescribeNegationTo(os);
     }
 
-    bool MatchAndExplain(LhsContainer lhs,
-                         MatchResultListener* listener) const override {
+    bool MatchAndExplain(LhsContainer lhs, 
+                         MatchResultListener* listener) const override { 
       LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
       const size_t actual_size = lhs_stl_container.size();
       if (actual_size != rhs_.size()) {
@@ -2579,13 +2579,13 @@ class PointwiseMatcher {
       for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
         if (listener->IsInterested()) {
           StringMatchResultListener inner_listener;
-          // Create InnerMatcherArg as a temporarily object to avoid it outlives
-          // *left and *right. Dereference or the conversion to `const T&` may
-          // return temp objects, e.g for vector<bool>.
+          // Create InnerMatcherArg as a temporarily object to avoid it outlives 
+          // *left and *right. Dereference or the conversion to `const T&` may 
+          // return temp objects, e.g for vector<bool>. 
           if (!mono_tuple_matcher_.MatchAndExplain(
-                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
-                                  ImplicitCast_<const RhsValue&>(*right)),
-                  &inner_listener)) {
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), 
+                                  ImplicitCast_<const RhsValue&>(*right)), 
+                  &inner_listener)) { 
             *listener << "where the value pair (";
             UniversalPrint(*left, listener->stream());
             *listener << ", ";
@@ -2595,9 +2595,9 @@ class PointwiseMatcher {
             return false;
           }
         } else {
-          if (!mono_tuple_matcher_.Matches(
-                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
-                                  ImplicitCast_<const RhsValue&>(*right))))
+          if (!mono_tuple_matcher_.Matches( 
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left), 
+                                  ImplicitCast_<const RhsValue&>(*right)))) 
             return false;
         }
       }
@@ -2667,18 +2667,18 @@ class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
       : QuantifierMatcherImpl<Container>(inner_matcher) {}
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "contains at least one element that ";
     this->inner_matcher_.DescribeTo(os);
   }
 
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "doesn't contain any element that ";
     this->inner_matcher_.DescribeTo(os);
   }
 
-  bool MatchAndExplain(Container container,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(Container container, 
+                       MatchResultListener* listener) const override { 
     return this->MatchAndExplainImpl(false, container, listener);
   }
 };
@@ -2693,18 +2693,18 @@ class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
       : QuantifierMatcherImpl<Container>(inner_matcher) {}
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "only contains elements that ";
     this->inner_matcher_.DescribeTo(os);
   }
 
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "contains some element that ";
     this->inner_matcher_.DescribeNegationTo(os);
   }
 
-  bool MatchAndExplain(Container container,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(Container container, 
+                       MatchResultListener* listener) const override { 
     return this->MatchAndExplainImpl(true, container, listener);
   }
 };
@@ -2717,8 +2717,8 @@ class ContainsMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    return Matcher<Container>(
-        new ContainsMatcherImpl<const Container&>(inner_matcher_));
+    return Matcher<Container>( 
+        new ContainsMatcherImpl<const Container&>(inner_matcher_)); 
   }
 
  private:
@@ -2733,38 +2733,38 @@ class EachMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    return Matcher<Container>(
-        new EachMatcherImpl<const Container&>(inner_matcher_));
+    return Matcher<Container>( 
+        new EachMatcherImpl<const Container&>(inner_matcher_)); 
   }
 
  private:
   const M inner_matcher_;
 };
 
-struct Rank1 {};
-struct Rank0 : Rank1 {};
-
-namespace pair_getters {
-using std::get;
-template <typename T>
-auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT
-  return get<0>(x);
-}
-template <typename T>
-auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
-  return x.first;
-}
-
-template <typename T>
-auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
-  return get<1>(x);
-}
-template <typename T>
-auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
-  return x.second;
-}
-}  // namespace pair_getters
-
+struct Rank1 {}; 
+struct Rank0 : Rank1 {}; 
+ 
+namespace pair_getters { 
+using std::get; 
+template <typename T> 
+auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT 
+  return get<0>(x); 
+} 
+template <typename T> 
+auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT 
+  return x.first; 
+} 
+ 
+template <typename T> 
+auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT 
+  return get<1>(x); 
+} 
+template <typename T> 
+auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT 
+  return x.second; 
+} 
+}  // namespace pair_getters 
+ 
 // Implements Key(inner_matcher) for the given argument pair type.
 // Key(inner_matcher) matches an std::pair whose 'first' field matches
 // inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
@@ -2781,14 +2781,14 @@ class KeyMatcherImpl : public MatcherInterface<PairType> {
           testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
   }
 
-  // Returns true if and only if 'key_value.first' (the key) matches the inner
-  // matcher.
-  bool MatchAndExplain(PairType key_value,
-                       MatchResultListener* listener) const override {
+  // Returns true if and only if 'key_value.first' (the key) matches the inner 
+  // matcher. 
+  bool MatchAndExplain(PairType key_value, 
+                       MatchResultListener* listener) const override { 
     StringMatchResultListener inner_listener;
-    const bool match = inner_matcher_.MatchAndExplain(
-        pair_getters::First(key_value, Rank0()), &inner_listener);
-    const std::string explanation = inner_listener.str();
+    const bool match = inner_matcher_.MatchAndExplain( 
+        pair_getters::First(key_value, Rank0()), &inner_listener); 
+    const std::string explanation = inner_listener.str(); 
     if (explanation != "") {
       *listener << "whose first field is a value " << explanation;
     }
@@ -2796,13 +2796,13 @@ class KeyMatcherImpl : public MatcherInterface<PairType> {
   }
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "has a key that ";
     inner_matcher_.DescribeTo(os);
   }
 
   // Describes what the negation of this matcher does.
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "doesn't have a key that ";
     inner_matcher_.DescribeTo(os);
   }
@@ -2819,57 +2819,57 @@ class KeyMatcher {
 
   template <typename PairType>
   operator Matcher<PairType>() const {
-    return Matcher<PairType>(
-        new KeyMatcherImpl<const PairType&>(matcher_for_key_));
+    return Matcher<PairType>( 
+        new KeyMatcherImpl<const PairType&>(matcher_for_key_)); 
   }
 
  private:
   const M matcher_for_key_;
 };
 
-// Implements polymorphic Address(matcher_for_address).
-template <typename InnerMatcher>
-class AddressMatcher {
- public:
-  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}
-
-  template <typename Type>
-  operator Matcher<Type>() const {  // NOLINT
-    return Matcher<Type>(new Impl<const Type&>(matcher_));
-  }
-
- private:
-  // The monomorphic implementation that works for a particular object type.
-  template <typename Type>
-  class Impl : public MatcherInterface<Type> {
-   public:
-    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;
-    explicit Impl(const InnerMatcher& matcher)
-        : matcher_(MatcherCast<Address>(matcher)) {}
-
-    void DescribeTo(::std::ostream* os) const override {
-      *os << "has address that ";
-      matcher_.DescribeTo(os);
-    }
-
-    void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "does not have address that ";
-      matcher_.DescribeTo(os);
-    }
-
-    bool MatchAndExplain(Type object,
-                         MatchResultListener* listener) const override {
-      *listener << "which has address ";
-      Address address = std::addressof(object);
-      return MatchPrintAndExplain(address, matcher_, listener);
-    }
-
-   private:
-    const Matcher<Address> matcher_;
-  };
-  const InnerMatcher matcher_;
-};
-
+// Implements polymorphic Address(matcher_for_address). 
+template <typename InnerMatcher> 
+class AddressMatcher { 
+ public: 
+  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {} 
+ 
+  template <typename Type> 
+  operator Matcher<Type>() const {  // NOLINT 
+    return Matcher<Type>(new Impl<const Type&>(matcher_)); 
+  } 
+ 
+ private: 
+  // The monomorphic implementation that works for a particular object type. 
+  template <typename Type> 
+  class Impl : public MatcherInterface<Type> { 
+   public: 
+    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *; 
+    explicit Impl(const InnerMatcher& matcher) 
+        : matcher_(MatcherCast<Address>(matcher)) {} 
+ 
+    void DescribeTo(::std::ostream* os) const override { 
+      *os << "has address that "; 
+      matcher_.DescribeTo(os); 
+    } 
+ 
+    void DescribeNegationTo(::std::ostream* os) const override { 
+      *os << "does not have address that "; 
+      matcher_.DescribeTo(os); 
+    } 
+ 
+    bool MatchAndExplain(Type object, 
+                         MatchResultListener* listener) const override { 
+      *listener << "which has address "; 
+      Address address = std::addressof(object); 
+      return MatchPrintAndExplain(address, matcher_, listener); 
+    } 
+ 
+   private: 
+    const Matcher<Address> matcher_; 
+  }; 
+  const InnerMatcher matcher_; 
+}; 
+ 
 // Implements Pair(first_matcher, second_matcher) for the given argument pair
 // type with its two matchers. See Pair() function below.
 template <typename PairType>
@@ -2888,7 +2888,7 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
   }
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     *os << "has a first field that ";
     first_matcher_.DescribeTo(os);
     *os << ", and has a second field that ";
@@ -2896,32 +2896,32 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
   }
 
   // Describes what the negation of this matcher does.
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     *os << "has a first field that ";
     first_matcher_.DescribeNegationTo(os);
     *os << ", or has a second field that ";
     second_matcher_.DescribeNegationTo(os);
   }
 
-  // Returns true if and only if 'a_pair.first' matches first_matcher and
-  // 'a_pair.second' matches second_matcher.
-  bool MatchAndExplain(PairType a_pair,
-                       MatchResultListener* listener) const override {
+  // Returns true if and only if 'a_pair.first' matches first_matcher and 
+  // 'a_pair.second' matches second_matcher. 
+  bool MatchAndExplain(PairType a_pair, 
+                       MatchResultListener* listener) const override { 
     if (!listener->IsInterested()) {
       // If the listener is not interested, we don't need to construct the
       // explanation.
-      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
-             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
+      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) && 
+             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0())); 
     }
     StringMatchResultListener first_inner_listener;
-    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
+    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()), 
                                         &first_inner_listener)) {
       *listener << "whose first field does not match";
       PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
       return false;
     }
     StringMatchResultListener second_inner_listener;
-    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
+    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()), 
                                          &second_inner_listener)) {
       *listener << "whose second field does not match";
       PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
@@ -2933,8 +2933,8 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
   }
 
  private:
-  void ExplainSuccess(const std::string& first_explanation,
-                      const std::string& second_explanation,
+  void ExplainSuccess(const std::string& first_explanation, 
+                      const std::string& second_explanation, 
                       MatchResultListener* listener) const {
     *listener << "whose both fields match";
     if (first_explanation != "") {
@@ -2964,8 +2964,8 @@ class PairMatcher {
 
   template <typename PairType>
   operator Matcher<PairType> () const {
-    return Matcher<PairType>(
-        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
+    return Matcher<PairType>( 
+        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_)); 
   }
 
  private:
@@ -2973,203 +2973,203 @@ class PairMatcher {
   const SecondMatcher second_matcher_;
 };
 
-template <typename T, size_t... I>
-auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
-    -> decltype(std::tie(get<I>(t)...)) {
-  static_assert(std::tuple_size<T>::value == sizeof...(I),
-                "Number of arguments doesn't match the number of fields.");
-  return std::tie(get<I>(t)...);
-}
-
-#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
-  const auto& [a] = t;
-  return std::tie(a);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
-  const auto& [a, b] = t;
-  return std::tie(a, b);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
-  const auto& [a, b, c] = t;
-  return std::tie(a, b, c);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
-  const auto& [a, b, c, d] = t;
-  return std::tie(a, b, c, d);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
-  const auto& [a, b, c, d, e] = t;
-  return std::tie(a, b, c, d, e);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
-  const auto& [a, b, c, d, e, f] = t;
-  return std::tie(a, b, c, d, e, f);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
-  const auto& [a, b, c, d, e, f, g] = t;
-  return std::tie(a, b, c, d, e, f, g);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
-  const auto& [a, b, c, d, e, f, g, h] = t;
-  return std::tie(a, b, c, d, e, f, g, h);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
-}
-template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
-  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
-  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
-}
-#endif  // defined(__cpp_structured_bindings)
-
-template <size_t I, typename T>
-auto UnpackStruct(const T& t)
-    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
-  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
-}
-
-// Helper function to do comma folding in C++11.
-// The array ensures left-to-right order of evaluation.
-// Usage: VariadicExpand({expr...});
-template <typename T, size_t N>
-void VariadicExpand(const T (&)[N]) {}
-
-template <typename Struct, typename StructSize>
-class FieldsAreMatcherImpl;
-
-template <typename Struct, size_t... I>
-class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
-    : public MatcherInterface<Struct> {
-  using UnpackedType =
-      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
-  using MatchersType = std::tuple<
-      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;
-
- public:
-  template <typename Inner>
-  explicit FieldsAreMatcherImpl(const Inner& matchers)
-      : matchers_(testing::SafeMatcherCast<
-                  const typename std::tuple_element<I, UnpackedType>::type&>(
-            std::get<I>(matchers))...) {}
-
-  void DescribeTo(::std::ostream* os) const override {
-    const char* separator = "";
-    VariadicExpand(
-        {(*os << separator << "has field #" << I << " that ",
-          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const override {
-    const char* separator = "";
-    VariadicExpand({(*os << separator << "has field #" << I << " that ",
-                     std::get<I>(matchers_).DescribeNegationTo(os),
-                     separator = ", or ")...});
-  }
-
-  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {
-    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);
-  }
-
- private:
-  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {
-    if (!listener->IsInterested()) {
-      // If the listener is not interested, we don't need to construct the
-      // explanation.
-      bool good = true;
-      VariadicExpand({good = good && std::get<I>(matchers_).Matches(
-                                         std::get<I>(tuple))...});
-      return good;
-    }
-
-    size_t failed_pos = ~size_t{};
-
-    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
-
-    VariadicExpand(
-        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
-                                        std::get<I>(tuple), &inner_listener[I])
-             ? failed_pos = I
-             : 0 ...});
-    if (failed_pos != ~size_t{}) {
-      *listener << "whose field #" << failed_pos << " does not match";
-      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());
-      return false;
-    }
-
-    *listener << "whose all elements match";
-    const char* separator = ", where";
-    for (size_t index = 0; index < sizeof...(I); ++index) {
-      const std::string str = inner_listener[index].str();
-      if (!str.empty()) {
-        *listener << separator << " field #" << index << " is a value " << str;
-        separator = ", and";
-      }
-    }
-
-    return true;
-  }
-
-  MatchersType matchers_;
-};
-
-template <typename... Inner>
-class FieldsAreMatcher {
- public:
-  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}
-
-  template <typename Struct>
-  operator Matcher<Struct>() const {  // NOLINT
-    return Matcher<Struct>(
-        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
-            matchers_));
-  }
-
- private:
-  std::tuple<Inner...> matchers_;
-};
-
+template <typename T, size_t... I> 
+auto UnpackStructImpl(const T& t, IndexSequence<I...>, int) 
+    -> decltype(std::tie(get<I>(t)...)) { 
+  static_assert(std::tuple_size<T>::value == sizeof...(I), 
+                "Number of arguments doesn't match the number of fields."); 
+  return std::tie(get<I>(t)...); 
+} 
+ 
+#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) { 
+  const auto& [a] = t; 
+  return std::tie(a); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) { 
+  const auto& [a, b] = t; 
+  return std::tie(a, b); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) { 
+  const auto& [a, b, c] = t; 
+  return std::tie(a, b, c); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) { 
+  const auto& [a, b, c, d] = t; 
+  return std::tie(a, b, c, d); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) { 
+  const auto& [a, b, c, d, e] = t; 
+  return std::tie(a, b, c, d, e); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) { 
+  const auto& [a, b, c, d, e, f] = t; 
+  return std::tie(a, b, c, d, e, f); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) { 
+  const auto& [a, b, c, d, e, f, g] = t; 
+  return std::tie(a, b, c, d, e, f, g); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) { 
+  const auto& [a, b, c, d, e, f, g, h] = t; 
+  return std::tie(a, b, c, d, e, f, g, h); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o); 
+} 
+template <typename T> 
+auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) { 
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t; 
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p); 
+} 
+#endif  // defined(__cpp_structured_bindings) 
+ 
+template <size_t I, typename T> 
+auto UnpackStruct(const T& t) 
+    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) { 
+  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0); 
+} 
+ 
+// Helper function to do comma folding in C++11. 
+// The array ensures left-to-right order of evaluation. 
+// Usage: VariadicExpand({expr...}); 
+template <typename T, size_t N> 
+void VariadicExpand(const T (&)[N]) {} 
+ 
+template <typename Struct, typename StructSize> 
+class FieldsAreMatcherImpl; 
+ 
+template <typename Struct, size_t... I> 
+class FieldsAreMatcherImpl<Struct, IndexSequence<I...>> 
+    : public MatcherInterface<Struct> { 
+  using UnpackedType = 
+      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>())); 
+  using MatchersType = std::tuple< 
+      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>; 
+ 
+ public: 
+  template <typename Inner> 
+  explicit FieldsAreMatcherImpl(const Inner& matchers) 
+      : matchers_(testing::SafeMatcherCast< 
+                  const typename std::tuple_element<I, UnpackedType>::type&>( 
+            std::get<I>(matchers))...) {} 
+ 
+  void DescribeTo(::std::ostream* os) const override { 
+    const char* separator = ""; 
+    VariadicExpand( 
+        {(*os << separator << "has field #" << I << " that ", 
+          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...}); 
+  } 
+ 
+  void DescribeNegationTo(::std::ostream* os) const override { 
+    const char* separator = ""; 
+    VariadicExpand({(*os << separator << "has field #" << I << " that ", 
+                     std::get<I>(matchers_).DescribeNegationTo(os), 
+                     separator = ", or ")...}); 
+  } 
+ 
+  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override { 
+    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener); 
+  } 
+ 
+ private: 
+  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const { 
+    if (!listener->IsInterested()) { 
+      // If the listener is not interested, we don't need to construct the 
+      // explanation. 
+      bool good = true; 
+      VariadicExpand({good = good && std::get<I>(matchers_).Matches( 
+                                         std::get<I>(tuple))...}); 
+      return good; 
+    } 
+ 
+    size_t failed_pos = ~size_t{}; 
+ 
+    std::vector<StringMatchResultListener> inner_listener(sizeof...(I)); 
+ 
+    VariadicExpand( 
+        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain( 
+                                        std::get<I>(tuple), &inner_listener[I]) 
+             ? failed_pos = I 
+             : 0 ...}); 
+    if (failed_pos != ~size_t{}) { 
+      *listener << "whose field #" << failed_pos << " does not match"; 
+      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream()); 
+      return false; 
+    } 
+ 
+    *listener << "whose all elements match"; 
+    const char* separator = ", where"; 
+    for (size_t index = 0; index < sizeof...(I); ++index) { 
+      const std::string str = inner_listener[index].str(); 
+      if (!str.empty()) { 
+        *listener << separator << " field #" << index << " is a value " << str; 
+        separator = ", and"; 
+      } 
+    } 
+ 
+    return true; 
+  } 
+ 
+  MatchersType matchers_; 
+}; 
+ 
+template <typename... Inner> 
+class FieldsAreMatcher { 
+ public: 
+  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {} 
+ 
+  template <typename Struct> 
+  operator Matcher<Struct>() const {  // NOLINT 
+    return Matcher<Struct>( 
+        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>( 
+            matchers_)); 
+  } 
+ 
+ private: 
+  std::tuple<Inner...> matchers_; 
+}; 
+ 
 // Implements ElementsAre() and ElementsAreArray().
 template <typename Container>
 class ElementsAreMatcherImpl : public MatcherInterface<Container> {
@@ -3190,7 +3190,7 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
   }
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     if (count() == 0) {
       *os << "is empty";
     } else if (count() == 1) {
@@ -3209,7 +3209,7 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
   }
 
   // Describes what the negation of this matcher does.
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     if (count() == 0) {
       *os << "isn't empty";
       return;
@@ -3225,15 +3225,15 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
     }
   }
 
-  bool MatchAndExplain(Container container,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(Container container, 
+                       MatchResultListener* listener) const override { 
     // To work with stream-like "containers", we must only walk
     // through the elements in one pass.
 
     const bool listener_interested = listener->IsInterested();
 
     // explanations[i] is the explanation of the element at index i.
-    ::std::vector<std::string> explanations(count());
+    ::std::vector<std::string> explanations(count()); 
     StlContainerReference stl_container = View::ConstReference(container);
     typename StlContainer::const_iterator it = stl_container.begin();
     size_t exam_pos = 0;
@@ -3292,7 +3292,7 @@ class ElementsAreMatcherImpl : public MatcherInterface<Container> {
     if (listener_interested) {
       bool reason_printed = false;
       for (size_t i = 0; i != count(); ++i) {
-        const std::string& s = explanations[i];
+        const std::string& s = explanations[i]; 
         if (!s.empty()) {
           if (reason_printed) {
             *listener << ",\nand ";
@@ -3343,7 +3343,7 @@ class GTEST_API_ MatchMatrix {
 
   void Randomize();
 
-  std::string DebugString() const;
+  std::string DebugString() const; 
 
  private:
   size_t SpaceIndex(size_t ilhs, size_t irhs) const {
@@ -3367,23 +3367,23 @@ typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
 GTEST_API_ ElementMatcherPairs
 FindMaxBipartiteMatching(const MatchMatrix& g);
 
-struct UnorderedMatcherRequire {
-  enum Flags {
-    Superset = 1 << 0,
-    Subset = 1 << 1,
-    ExactMatch = Superset | Subset,
-  };
-};
+struct UnorderedMatcherRequire { 
+  enum Flags { 
+    Superset = 1 << 0, 
+    Subset = 1 << 1, 
+    ExactMatch = Superset | Subset, 
+  }; 
+}; 
 
 // Untyped base class for implementing UnorderedElementsAre.  By
 // putting logic that's not specific to the element type here, we
 // reduce binary bloat and increase compilation speed.
 class GTEST_API_ UnorderedElementsAreMatcherImplBase {
  protected:
-  explicit UnorderedElementsAreMatcherImplBase(
-      UnorderedMatcherRequire::Flags matcher_flags)
-      : match_flags_(matcher_flags) {}
-
+  explicit UnorderedElementsAreMatcherImplBase( 
+      UnorderedMatcherRequire::Flags matcher_flags) 
+      : match_flags_(matcher_flags) {} 
+ 
   // A vector of matcher describers, one for each element matcher.
   // Does not own the describers (and thus can be used only when the
   // element matchers are alive).
@@ -3395,13 +3395,13 @@ class GTEST_API_ UnorderedElementsAreMatcherImplBase {
   // Describes the negation of this UnorderedElementsAre matcher.
   void DescribeNegationToImpl(::std::ostream* os) const;
 
-  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,
-                         const MatchMatrix& matrix,
-                         MatchResultListener* listener) const;
-
-  bool FindPairing(const MatchMatrix& matrix,
-                   MatchResultListener* listener) const;
+  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts, 
+                         const MatchMatrix& matrix, 
+                         MatchResultListener* listener) const; 
 
+  bool FindPairing(const MatchMatrix& matrix, 
+                   MatchResultListener* listener) const; 
+ 
   MatcherDescriberVec& matcher_describers() {
     return matcher_describers_;
   }
@@ -3410,15 +3410,15 @@ class GTEST_API_ UnorderedElementsAreMatcherImplBase {
     return Message() << n << " element" << (n == 1 ? "" : "s");
   }
 
-  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }
-
+  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; } 
+ 
  private:
-  UnorderedMatcherRequire::Flags match_flags_;
+  UnorderedMatcherRequire::Flags match_flags_; 
   MatcherDescriberVec matcher_describers_;
 };
 
-// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and
-// IsSupersetOf.
+// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and 
+// IsSupersetOf. 
 template <typename Container>
 class UnorderedElementsAreMatcherImpl
     : public MatcherInterface<Container>,
@@ -3432,72 +3432,72 @@ class UnorderedElementsAreMatcherImpl
   typedef typename StlContainer::value_type Element;
 
   template <typename InputIter>
-  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
-                                  InputIter first, InputIter last)
-      : UnorderedElementsAreMatcherImplBase(matcher_flags) {
+  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags, 
+                                  InputIter first, InputIter last) 
+      : UnorderedElementsAreMatcherImplBase(matcher_flags) { 
     for (; first != last; ++first) {
       matchers_.push_back(MatcherCast<const Element&>(*first));
     }
-    for (const auto& m : matchers_) {
-      matcher_describers().push_back(m.GetDescriber());
-    }
+    for (const auto& m : matchers_) { 
+      matcher_describers().push_back(m.GetDescriber()); 
+    } 
   }
 
   // Describes what this matcher does.
-  void DescribeTo(::std::ostream* os) const override {
+  void DescribeTo(::std::ostream* os) const override { 
     return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
   }
 
   // Describes what the negation of this matcher does.
-  void DescribeNegationTo(::std::ostream* os) const override {
+  void DescribeNegationTo(::std::ostream* os) const override { 
     return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
   }
 
-  bool MatchAndExplain(Container container,
-                       MatchResultListener* listener) const override {
+  bool MatchAndExplain(Container container, 
+                       MatchResultListener* listener) const override { 
     StlContainerReference stl_container = View::ConstReference(container);
-    ::std::vector<std::string> element_printouts;
-    MatchMatrix matrix =
-        AnalyzeElements(stl_container.begin(), stl_container.end(),
-                        &element_printouts, listener);
+    ::std::vector<std::string> element_printouts; 
+    MatchMatrix matrix = 
+        AnalyzeElements(stl_container.begin(), stl_container.end(), 
+                        &element_printouts, listener); 
 
-    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
+    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) { 
       return true;
     }
-
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      if (matrix.LhsSize() != matrix.RhsSize()) {
-        // The element count doesn't match.  If the container is empty,
-        // there's no need to explain anything as Google Mock already
-        // prints the empty container. Otherwise we just need to show
-        // how many elements there actually are.
-        if (matrix.LhsSize() != 0 && listener->IsInterested()) {
-          *listener << "which has " << Elements(matrix.LhsSize());
-        }
-        return false;
+ 
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) { 
+      if (matrix.LhsSize() != matrix.RhsSize()) { 
+        // The element count doesn't match.  If the container is empty, 
+        // there's no need to explain anything as Google Mock already 
+        // prints the empty container. Otherwise we just need to show 
+        // how many elements there actually are. 
+        if (matrix.LhsSize() != 0 && listener->IsInterested()) { 
+          *listener << "which has " << Elements(matrix.LhsSize()); 
+        } 
+        return false; 
       }
     }
 
-    return VerifyMatchMatrix(element_printouts, matrix, listener) &&
+    return VerifyMatchMatrix(element_printouts, matrix, listener) && 
            FindPairing(matrix, listener);
   }
 
  private:
   template <typename ElementIter>
   MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
-                              ::std::vector<std::string>* element_printouts,
+                              ::std::vector<std::string>* element_printouts, 
                               MatchResultListener* listener) const {
     element_printouts->clear();
     ::std::vector<char> did_match;
     size_t num_elements = 0;
-    DummyMatchResultListener dummy;
+    DummyMatchResultListener dummy; 
     for (; elem_first != elem_last; ++num_elements, ++elem_first) {
       if (listener->IsInterested()) {
         element_printouts->push_back(PrintToString(*elem_first));
       }
       for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
-        did_match.push_back(
-            matchers_[irhs].MatchAndExplain(*elem_first, &dummy));
+        did_match.push_back( 
+            matchers_[irhs].MatchAndExplain(*elem_first, &dummy)); 
       }
     }
 
@@ -3511,7 +3511,7 @@ class UnorderedElementsAreMatcherImpl
     return matrix;
   }
 
-  ::std::vector<Matcher<const Element&> > matchers_;
+  ::std::vector<Matcher<const Element&> > matchers_; 
 };
 
 // Functor for use in TransformTuple.
@@ -3538,13 +3538,13 @@ class UnorderedElementsAreMatcher {
     typedef typename View::value_type Element;
     typedef ::std::vector<Matcher<const Element&> > MatcherVec;
     MatcherVec matchers;
-    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value); 
     TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
                          ::std::back_inserter(matchers));
-    return Matcher<Container>(
-        new UnorderedElementsAreMatcherImpl<const Container&>(
-            UnorderedMatcherRequire::ExactMatch, matchers.begin(),
-            matchers.end()));
+    return Matcher<Container>( 
+        new UnorderedElementsAreMatcherImpl<const Container&>( 
+            UnorderedMatcherRequire::ExactMatch, matchers.begin(), 
+            matchers.end())); 
   }
 
  private:
@@ -3559,45 +3559,45 @@ class ElementsAreMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    GTEST_COMPILE_ASSERT_(
-        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
-            ::std::tuple_size<MatcherTuple>::value < 2,
-        use_UnorderedElementsAre_with_hash_tables);
-
+    GTEST_COMPILE_ASSERT_( 
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value || 
+            ::std::tuple_size<MatcherTuple>::value < 2, 
+        use_UnorderedElementsAre_with_hash_tables); 
+ 
     typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type View;
     typedef typename View::value_type Element;
     typedef ::std::vector<Matcher<const Element&> > MatcherVec;
     MatcherVec matchers;
-    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value); 
     TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
                          ::std::back_inserter(matchers));
-    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
-        matchers.begin(), matchers.end()));
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( 
+        matchers.begin(), matchers.end())); 
   }
 
  private:
   const MatcherTuple matchers_;
 };
 
-// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().
+// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf(). 
 template <typename T>
 class UnorderedElementsAreArrayMatcher {
  public:
   template <typename Iter>
-  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,
-                                   Iter first, Iter last)
-      : match_flags_(match_flags), matchers_(first, last) {}
+  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags, 
+                                   Iter first, Iter last) 
+      : match_flags_(match_flags), matchers_(first, last) {} 
 
   template <typename Container>
   operator Matcher<Container>() const {
-    return Matcher<Container>(
-        new UnorderedElementsAreMatcherImpl<const Container&>(
-            match_flags_, matchers_.begin(), matchers_.end()));
+    return Matcher<Container>( 
+        new UnorderedElementsAreMatcherImpl<const Container&>( 
+            match_flags_, matchers_.begin(), matchers_.end())); 
   }
 
  private:
-  UnorderedMatcherRequire::Flags match_flags_;
+  UnorderedMatcherRequire::Flags match_flags_; 
   ::std::vector<T> matchers_;
 };
 
@@ -3610,11 +3610,11 @@ class ElementsAreArrayMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    GTEST_COMPILE_ASSERT_(
-        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
-        use_UnorderedElementsAreArray_with_hash_tables);
-
-    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+    GTEST_COMPILE_ASSERT_( 
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value, 
+        use_UnorderedElementsAreArray_with_hash_tables); 
+ 
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>( 
         matchers_.begin(), matchers_.end()));
   }
 
@@ -3624,8 +3624,8 @@ class ElementsAreArrayMatcher {
 
 // Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
 // of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
-// second) is a polymorphic matcher that matches a value x if and only if
-// tm matches tuple (x, second).  Useful for implementing
+// second) is a polymorphic matcher that matches a value x if and only if 
+// tm matches tuple (x, second).  Useful for implementing 
 // UnorderedPointwise() in terms of UnorderedElementsAreArray().
 //
 // BoundSecondMatcher is copyable and assignable, as we need to put
@@ -3637,8 +3637,8 @@ class BoundSecondMatcher {
   BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
       : tuple2_matcher_(tm), second_value_(second) {}
 
-  BoundSecondMatcher(const BoundSecondMatcher& other) = default;
-
+  BoundSecondMatcher(const BoundSecondMatcher& other) = default; 
+ 
   template <typename T>
   operator Matcher<T>() const {
     return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
@@ -3660,20 +3660,20 @@ class BoundSecondMatcher {
   template <typename T>
   class Impl : public MatcherInterface<T> {
    public:
-    typedef ::std::tuple<T, Second> ArgTuple;
+    typedef ::std::tuple<T, Second> ArgTuple; 
 
     Impl(const Tuple2Matcher& tm, const Second& second)
         : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
           second_value_(second) {}
 
-    void DescribeTo(::std::ostream* os) const override {
+    void DescribeTo(::std::ostream* os) const override { 
       *os << "and ";
       UniversalPrint(second_value_, os);
       *os << " ";
       mono_tuple2_matcher_.DescribeTo(os);
     }
 
-    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override { 
       return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
                                                   listener);
     }
@@ -3689,8 +3689,8 @@ class BoundSecondMatcher {
 
 // Given a 2-tuple matcher tm and a value second,
 // MatcherBindSecond(tm, second) returns a matcher that matches a
-// value x if and only if tm matches tuple (x, second).  Useful for
-// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().
+// value x if and only if tm matches tuple (x, second).  Useful for 
+// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray(). 
 template <typename Tuple2Matcher, typename Second>
 BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
     const Tuple2Matcher& tm, const Second& second) {
@@ -3702,262 +3702,262 @@ BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
 // 'negation' is false; otherwise returns the description of the
 // negation of the matcher.  'param_values' contains a list of strings
 // that are the print-out of the matcher's parameters.
-GTEST_API_ std::string FormatMatcherDescription(bool negation,
-                                                const char* matcher_name,
-                                                const Strings& param_values);
-
-// Implements a matcher that checks the value of a optional<> type variable.
-template <typename ValueMatcher>
-class OptionalMatcher {
- public:
-  explicit OptionalMatcher(const ValueMatcher& value_matcher)
-      : value_matcher_(value_matcher) {}
-
-  template <typename Optional>
-  operator Matcher<Optional>() const {
-    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
-  }
-
-  template <typename Optional>
-  class Impl : public MatcherInterface<Optional> {
-   public:
-    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;
-    typedef typename OptionalView::value_type ValueType;
-    explicit Impl(const ValueMatcher& value_matcher)
-        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}
-
-    void DescribeTo(::std::ostream* os) const override {
-      *os << "value ";
-      value_matcher_.DescribeTo(os);
-    }
-
-    void DescribeNegationTo(::std::ostream* os) const override {
-      *os << "value ";
-      value_matcher_.DescribeNegationTo(os);
-    }
-
-    bool MatchAndExplain(Optional optional,
-                         MatchResultListener* listener) const override {
-      if (!optional) {
-        *listener << "which is not engaged";
-        return false;
-      }
-      const ValueType& value = *optional;
-      StringMatchResultListener value_listener;
-      const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
-      *listener << "whose value " << PrintToString(value)
-                << (match ? " matches" : " doesn't match");
-      PrintIfNotEmpty(value_listener.str(), listener->stream());
-      return match;
-    }
-
-   private:
-    const Matcher<ValueType> value_matcher_;
-  };
-
- private:
-  const ValueMatcher value_matcher_;
-};
-
-namespace variant_matcher {
-// Overloads to allow VariantMatcher to do proper ADL lookup.
-template <typename T>
-void holds_alternative() {}
-template <typename T>
-void get() {}
-
-// Implements a matcher that checks the value of a variant<> type variable.
-template <typename T>
-class VariantMatcher {
- public:
-  explicit VariantMatcher(::testing::Matcher<const T&> matcher)
-      : matcher_(std::move(matcher)) {}
-
-  template <typename Variant>
-  bool MatchAndExplain(const Variant& value,
-                       ::testing::MatchResultListener* listener) const {
-    using std::get;
-    if (!listener->IsInterested()) {
-      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));
-    }
-
-    if (!holds_alternative<T>(value)) {
-      *listener << "whose value is not of type '" << GetTypeName() << "'";
-      return false;
-    }
-
-    const T& elem = get<T>(value);
-    StringMatchResultListener elem_listener;
-    const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
-    *listener << "whose value " << PrintToString(elem)
-              << (match ? " matches" : " doesn't match");
-    PrintIfNotEmpty(elem_listener.str(), listener->stream());
-    return match;
-  }
-
-  void DescribeTo(std::ostream* os) const {
-    *os << "is a variant<> with value of type '" << GetTypeName()
-        << "' and the value ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << "is a variant<> with value of type other than '" << GetTypeName()
-        << "' or the value ";
-    matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  static std::string GetTypeName() {
-#if GTEST_HAS_RTTI
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
-        return internal::GetTypeName<T>());
-#endif
-    return "the element type";
-  }
-
-  const ::testing::Matcher<const T&> matcher_;
-};
-
-}  // namespace variant_matcher
-
-namespace any_cast_matcher {
-
-// Overloads to allow AnyCastMatcher to do proper ADL lookup.
-template <typename T>
-void any_cast() {}
-
-// Implements a matcher that any_casts the value.
-template <typename T>
-class AnyCastMatcher {
- public:
-  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)
-      : matcher_(matcher) {}
-
-  template <typename AnyType>
-  bool MatchAndExplain(const AnyType& value,
-                       ::testing::MatchResultListener* listener) const {
-    if (!listener->IsInterested()) {
-      const T* ptr = any_cast<T>(&value);
-      return ptr != nullptr && matcher_.Matches(*ptr);
-    }
-
-    const T* elem = any_cast<T>(&value);
-    if (elem == nullptr) {
-      *listener << "whose value is not of type '" << GetTypeName() << "'";
-      return false;
-    }
-
-    StringMatchResultListener elem_listener;
-    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
-    *listener << "whose value " << PrintToString(*elem)
-              << (match ? " matches" : " doesn't match");
-    PrintIfNotEmpty(elem_listener.str(), listener->stream());
-    return match;
-  }
-
-  void DescribeTo(std::ostream* os) const {
-    *os << "is an 'any' type with value of type '" << GetTypeName()
-        << "' and the value ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << "is an 'any' type with value of type other than '" << GetTypeName()
-        << "' or the value ";
-    matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  static std::string GetTypeName() {
-#if GTEST_HAS_RTTI
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
-        return internal::GetTypeName<T>());
-#endif
-    return "the element type";
-  }
-
-  const ::testing::Matcher<const T&> matcher_;
-};
-
-}  // namespace any_cast_matcher
-
-// Implements the Args() matcher.
-template <class ArgsTuple, size_t... k>
-class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
- public:
-  using RawArgsTuple = typename std::decay<ArgsTuple>::type;
-  using SelectedArgs =
-      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
-  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;
-
-  template <typename InnerMatcher>
-  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
-      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
-
-  bool MatchAndExplain(ArgsTuple args,
-                       MatchResultListener* listener) const override {
-    // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
-    (void)args;
-    const SelectedArgs& selected_args =
-        std::forward_as_tuple(std::get<k>(args)...);
-    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);
-
-    PrintIndices(listener->stream());
-    *listener << "are " << PrintToString(selected_args);
-
-    StringMatchResultListener inner_listener;
-    const bool match =
-        inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
-    PrintIfNotEmpty(inner_listener.str(), listener->stream());
-    return match;
-  }
-
-  void DescribeTo(::std::ostream* os) const override {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const override {
-    *os << "are a tuple ";
-    PrintIndices(os);
-    inner_matcher_.DescribeNegationTo(os);
-  }
-
- private:
-  // Prints the indices of the selected fields.
-  static void PrintIndices(::std::ostream* os) {
-    *os << "whose fields (";
-    const char* sep = "";
-    // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
-    (void)sep;
-    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
-    (void)dummy;
-    *os << ") ";
-  }
-
-  MonomorphicInnerMatcher inner_matcher_;
-};
-
-template <class InnerMatcher, size_t... k>
-class ArgsMatcher {
- public:
-  explicit ArgsMatcher(InnerMatcher inner_matcher)
-      : inner_matcher_(std::move(inner_matcher)) {}
-
-  template <typename ArgsTuple>
-  operator Matcher<ArgsTuple>() const {  // NOLINT
-    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));
-  }
-
- private:
-  InnerMatcher inner_matcher_;
-};
-
+GTEST_API_ std::string FormatMatcherDescription(bool negation, 
+                                                const char* matcher_name, 
+                                                const Strings& param_values); 
+
+// Implements a matcher that checks the value of a optional<> type variable. 
+template <typename ValueMatcher> 
+class OptionalMatcher { 
+ public: 
+  explicit OptionalMatcher(const ValueMatcher& value_matcher) 
+      : value_matcher_(value_matcher) {} 
+ 
+  template <typename Optional> 
+  operator Matcher<Optional>() const { 
+    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_)); 
+  } 
+ 
+  template <typename Optional> 
+  class Impl : public MatcherInterface<Optional> { 
+   public: 
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView; 
+    typedef typename OptionalView::value_type ValueType; 
+    explicit Impl(const ValueMatcher& value_matcher) 
+        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {} 
+ 
+    void DescribeTo(::std::ostream* os) const override { 
+      *os << "value "; 
+      value_matcher_.DescribeTo(os); 
+    } 
+ 
+    void DescribeNegationTo(::std::ostream* os) const override { 
+      *os << "value "; 
+      value_matcher_.DescribeNegationTo(os); 
+    } 
+ 
+    bool MatchAndExplain(Optional optional, 
+                         MatchResultListener* listener) const override { 
+      if (!optional) { 
+        *listener << "which is not engaged"; 
+        return false; 
+      } 
+      const ValueType& value = *optional; 
+      StringMatchResultListener value_listener; 
+      const bool match = value_matcher_.MatchAndExplain(value, &value_listener); 
+      *listener << "whose value " << PrintToString(value) 
+                << (match ? " matches" : " doesn't match"); 
+      PrintIfNotEmpty(value_listener.str(), listener->stream()); 
+      return match; 
+    } 
+ 
+   private: 
+    const Matcher<ValueType> value_matcher_; 
+  }; 
+ 
+ private: 
+  const ValueMatcher value_matcher_; 
+}; 
+ 
+namespace variant_matcher { 
+// Overloads to allow VariantMatcher to do proper ADL lookup. 
+template <typename T> 
+void holds_alternative() {} 
+template <typename T> 
+void get() {} 
+ 
+// Implements a matcher that checks the value of a variant<> type variable. 
+template <typename T> 
+class VariantMatcher { 
+ public: 
+  explicit VariantMatcher(::testing::Matcher<const T&> matcher) 
+      : matcher_(std::move(matcher)) {} 
+ 
+  template <typename Variant> 
+  bool MatchAndExplain(const Variant& value, 
+                       ::testing::MatchResultListener* listener) const { 
+    using std::get; 
+    if (!listener->IsInterested()) { 
+      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value)); 
+    } 
+ 
+    if (!holds_alternative<T>(value)) { 
+      *listener << "whose value is not of type '" << GetTypeName() << "'"; 
+      return false; 
+    } 
+ 
+    const T& elem = get<T>(value); 
+    StringMatchResultListener elem_listener; 
+    const bool match = matcher_.MatchAndExplain(elem, &elem_listener); 
+    *listener << "whose value " << PrintToString(elem) 
+              << (match ? " matches" : " doesn't match"); 
+    PrintIfNotEmpty(elem_listener.str(), listener->stream()); 
+    return match; 
+  } 
+ 
+  void DescribeTo(std::ostream* os) const { 
+    *os << "is a variant<> with value of type '" << GetTypeName() 
+        << "' and the value "; 
+    matcher_.DescribeTo(os); 
+  } 
+ 
+  void DescribeNegationTo(std::ostream* os) const { 
+    *os << "is a variant<> with value of type other than '" << GetTypeName() 
+        << "' or the value "; 
+    matcher_.DescribeNegationTo(os); 
+  } 
+ 
+ private: 
+  static std::string GetTypeName() { 
+#if GTEST_HAS_RTTI 
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( 
+        return internal::GetTypeName<T>()); 
+#endif 
+    return "the element type"; 
+  } 
+ 
+  const ::testing::Matcher<const T&> matcher_; 
+}; 
+ 
+}  // namespace variant_matcher 
+ 
+namespace any_cast_matcher { 
+ 
+// Overloads to allow AnyCastMatcher to do proper ADL lookup. 
+template <typename T> 
+void any_cast() {} 
+ 
+// Implements a matcher that any_casts the value. 
+template <typename T> 
+class AnyCastMatcher { 
+ public: 
+  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher) 
+      : matcher_(matcher) {} 
+ 
+  template <typename AnyType> 
+  bool MatchAndExplain(const AnyType& value, 
+                       ::testing::MatchResultListener* listener) const { 
+    if (!listener->IsInterested()) { 
+      const T* ptr = any_cast<T>(&value); 
+      return ptr != nullptr && matcher_.Matches(*ptr); 
+    } 
+ 
+    const T* elem = any_cast<T>(&value); 
+    if (elem == nullptr) { 
+      *listener << "whose value is not of type '" << GetTypeName() << "'"; 
+      return false; 
+    } 
+ 
+    StringMatchResultListener elem_listener; 
+    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener); 
+    *listener << "whose value " << PrintToString(*elem) 
+              << (match ? " matches" : " doesn't match"); 
+    PrintIfNotEmpty(elem_listener.str(), listener->stream()); 
+    return match; 
+  } 
+ 
+  void DescribeTo(std::ostream* os) const { 
+    *os << "is an 'any' type with value of type '" << GetTypeName() 
+        << "' and the value "; 
+    matcher_.DescribeTo(os); 
+  } 
+ 
+  void DescribeNegationTo(std::ostream* os) const { 
+    *os << "is an 'any' type with value of type other than '" << GetTypeName() 
+        << "' or the value "; 
+    matcher_.DescribeNegationTo(os); 
+  } 
+ 
+ private: 
+  static std::string GetTypeName() { 
+#if GTEST_HAS_RTTI 
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( 
+        return internal::GetTypeName<T>()); 
+#endif 
+    return "the element type"; 
+  } 
+ 
+  const ::testing::Matcher<const T&> matcher_; 
+}; 
+ 
+}  // namespace any_cast_matcher 
+ 
+// Implements the Args() matcher. 
+template <class ArgsTuple, size_t... k> 
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> { 
+ public: 
+  using RawArgsTuple = typename std::decay<ArgsTuple>::type; 
+  using SelectedArgs = 
+      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>; 
+  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>; 
+ 
+  template <typename InnerMatcher> 
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher) 
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {} 
+ 
+  bool MatchAndExplain(ArgsTuple args, 
+                       MatchResultListener* listener) const override { 
+    // Workaround spurious C4100 on MSVC<=15.7 when k is empty. 
+    (void)args; 
+    const SelectedArgs& selected_args = 
+        std::forward_as_tuple(std::get<k>(args)...); 
+    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args); 
+ 
+    PrintIndices(listener->stream()); 
+    *listener << "are " << PrintToString(selected_args); 
+ 
+    StringMatchResultListener inner_listener; 
+    const bool match = 
+        inner_matcher_.MatchAndExplain(selected_args, &inner_listener); 
+    PrintIfNotEmpty(inner_listener.str(), listener->stream()); 
+    return match; 
+  } 
+ 
+  void DescribeTo(::std::ostream* os) const override { 
+    *os << "are a tuple "; 
+    PrintIndices(os); 
+    inner_matcher_.DescribeTo(os); 
+  } 
+ 
+  void DescribeNegationTo(::std::ostream* os) const override { 
+    *os << "are a tuple "; 
+    PrintIndices(os); 
+    inner_matcher_.DescribeNegationTo(os); 
+  } 
+ 
+ private: 
+  // Prints the indices of the selected fields. 
+  static void PrintIndices(::std::ostream* os) { 
+    *os << "whose fields ("; 
+    const char* sep = ""; 
+    // Workaround spurious C4189 on MSVC<=15.7 when k is empty. 
+    (void)sep; 
+    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...}; 
+    (void)dummy; 
+    *os << ") "; 
+  } 
+ 
+  MonomorphicInnerMatcher inner_matcher_; 
+}; 
+ 
+template <class InnerMatcher, size_t... k> 
+class ArgsMatcher { 
+ public: 
+  explicit ArgsMatcher(InnerMatcher inner_matcher) 
+      : inner_matcher_(std::move(inner_matcher)) {} 
+ 
+  template <typename ArgsTuple> 
+  operator Matcher<ArgsTuple>() const {  // NOLINT 
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_)); 
+  } 
+ 
+ private: 
+  InnerMatcher inner_matcher_; 
+}; 
+ 
 }  // namespace internal
 
-// ElementsAreArray(iterator_first, iterator_last)
+// ElementsAreArray(iterator_first, iterator_last) 
 // ElementsAreArray(pointer, count)
 // ElementsAreArray(array)
 // ElementsAreArray(container)
@@ -4004,26 +4004,26 @@ ElementsAreArray(::std::initializer_list<T> xs) {
   return ElementsAreArray(xs.begin(), xs.end());
 }
 
-// UnorderedElementsAreArray(iterator_first, iterator_last)
+// UnorderedElementsAreArray(iterator_first, iterator_last) 
 // UnorderedElementsAreArray(pointer, count)
 // UnorderedElementsAreArray(array)
 // UnorderedElementsAreArray(container)
 // UnorderedElementsAreArray({ e1, e2, ..., en })
 //
-// UnorderedElementsAreArray() verifies that a bijective mapping onto a
-// collection of matchers exists.
-//
-// The matchers can be specified as an array, a pointer and count, a container,
-// an initializer list, or an STL iterator range. In each of these cases, the
-// underlying matchers can be either values or matchers.
-
+// UnorderedElementsAreArray() verifies that a bijective mapping onto a 
+// collection of matchers exists. 
+// 
+// The matchers can be specified as an array, a pointer and count, a container, 
+// an initializer list, or an STL iterator range. In each of these cases, the 
+// underlying matchers can be either values or matchers. 
+ 
 template <typename Iter>
 inline internal::UnorderedElementsAreArrayMatcher<
     typename ::std::iterator_traits<Iter>::value_type>
 UnorderedElementsAreArray(Iter first, Iter last) {
   typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::UnorderedElementsAreArrayMatcher<T>(
-      internal::UnorderedMatcherRequire::ExactMatch, first, last);
+  return internal::UnorderedElementsAreArrayMatcher<T>( 
+      internal::UnorderedMatcherRequire::ExactMatch, first, last); 
 }
 
 template <typename T>
@@ -4063,21 +4063,21 @@ UnorderedElementsAreArray(::std::initializer_list<T> xs) {
 const internal::AnythingMatcher _ = {};
 // Creates a matcher that matches any value of the given type T.
 template <typename T>
-inline Matcher<T> A() {
-  return _;
-}
+inline Matcher<T> A() { 
+  return _; 
+} 
 
 // Creates a matcher that matches any value of the given type T.
 template <typename T>
-inline Matcher<T> An() {
-  return _;
-}
+inline Matcher<T> An() { 
+  return _; 
+} 
 
-template <typename T, typename M>
-Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
-    const M& value, std::false_type /* convertible_to_matcher */,
-    std::false_type /* convertible_to_T */) {
-  return Eq(value);
+template <typename T, typename M> 
+Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl( 
+    const M& value, std::false_type /* convertible_to_matcher */, 
+    std::false_type /* convertible_to_T */) { 
+  return Eq(value); 
 }
 
 // Creates a polymorphic matcher that matches any NULL pointer.
@@ -4099,11 +4099,11 @@ inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
   return internal::RefMatcher<T&>(x);
 }
 
-// Creates a polymorphic matcher that matches any NaN floating point.
-inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
-  return MakePolymorphicMatcher(internal::IsNanMatcher());
-}
-
+// Creates a polymorphic matcher that matches any NaN floating point. 
+inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() { 
+  return MakePolymorphicMatcher(internal::IsNanMatcher()); 
+} 
+ 
 // Creates a matcher that matches any double argument approximately
 // equal to rhs, where two NANs are considered unequal.
 inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
@@ -4168,7 +4168,7 @@ inline internal::PointeeMatcher<InnerMatcher> Pointee(
   return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
 }
 
-#if GTEST_HAS_RTTI
+#if GTEST_HAS_RTTI 
 // Creates a matcher that matches a pointer or reference that matches
 // inner_matcher when dynamic_cast<To> is applied.
 // The result of dynamic_cast<To> is forwarded to the inner matcher.
@@ -4181,12 +4181,12 @@ WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
   return MakePolymorphicMatcher(
       internal::WhenDynamicCastToMatcher<To>(inner_matcher));
 }
-#endif  // GTEST_HAS_RTTI
+#endif  // GTEST_HAS_RTTI 
 
 // Creates a matcher that matches an object whose given field matches
 // 'matcher'.  For example,
 //   Field(&Foo::number, Ge(5))
-// matches a Foo object x if and only if x.number >= 5.
+// matches a Foo object x if and only if x.number >= 5. 
 template <typename Class, typename FieldType, typename FieldMatcher>
 inline PolymorphicMatcher<
   internal::FieldMatcher<Class, FieldType> > Field(
@@ -4200,202 +4200,202 @@ inline PolymorphicMatcher<
   // to compile where bar is an int32 and m is a matcher for int64.
 }
 
-// Same as Field() but also takes the name of the field to provide better error
-// messages.
-template <typename Class, typename FieldType, typename FieldMatcher>
-inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
-    const std::string& field_name, FieldType Class::*field,
-    const FieldMatcher& matcher) {
-  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
-      field_name, field, MatcherCast<const FieldType&>(matcher)));
-}
-
+// Same as Field() but also takes the name of the field to provide better error 
+// messages. 
+template <typename Class, typename FieldType, typename FieldMatcher> 
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field( 
+    const std::string& field_name, FieldType Class::*field, 
+    const FieldMatcher& matcher) { 
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>( 
+      field_name, field, MatcherCast<const FieldType&>(matcher))); 
+} 
+ 
 // Creates a matcher that matches an object whose given property
 // matches 'matcher'.  For example,
 //   Property(&Foo::str, StartsWith("hi"))
-// matches a Foo object x if and only if x.str() starts with "hi".
+// matches a Foo object x if and only if x.str() starts with "hi". 
 template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const> >
-Property(PropertyType (Class::*property)() const,
-         const PropertyMatcher& matcher) {
+inline PolymorphicMatcher<internal::PropertyMatcher< 
+    Class, PropertyType, PropertyType (Class::*)() const> > 
+Property(PropertyType (Class::*property)() const, 
+         const PropertyMatcher& matcher) { 
   return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType,
-                                PropertyType (Class::*)() const>(
-          property, MatcherCast<const PropertyType&>(matcher)));
+      internal::PropertyMatcher<Class, PropertyType, 
+                                PropertyType (Class::*)() const>( 
+          property, MatcherCast<const PropertyType&>(matcher))); 
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   Property(&Foo::bar, m)
   // to compile where bar() returns an int32 and m is a matcher for int64.
 }
 
-// Same as Property() above, but also takes the name of the property to provide
-// better error messages.
-template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const> >
-Property(const std::string& property_name,
-         PropertyType (Class::*property)() const,
-         const PropertyMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType,
-                                PropertyType (Class::*)() const>(
-          property_name, property, MatcherCast<const PropertyType&>(matcher)));
-}
-
-// The same as above but for reference-qualified member functions.
-template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const &> >
-Property(PropertyType (Class::*property)() const &,
-         const PropertyMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType,
-                                PropertyType (Class::*)() const&>(
-          property, MatcherCast<const PropertyType&>(matcher)));
-}
-
-// Three-argument form for reference-qualified member functions.
-template <typename Class, typename PropertyType, typename PropertyMatcher>
-inline PolymorphicMatcher<internal::PropertyMatcher<
-    Class, PropertyType, PropertyType (Class::*)() const &> >
-Property(const std::string& property_name,
-         PropertyType (Class::*property)() const &,
-         const PropertyMatcher& matcher) {
-  return MakePolymorphicMatcher(
-      internal::PropertyMatcher<Class, PropertyType,
-                                PropertyType (Class::*)() const&>(
-          property_name, property, MatcherCast<const PropertyType&>(matcher)));
-}
-
-// Creates a matcher that matches an object if and only if the result of
-// applying a callable to x matches 'matcher'. For example,
+// Same as Property() above, but also takes the name of the property to provide 
+// better error messages. 
+template <typename Class, typename PropertyType, typename PropertyMatcher> 
+inline PolymorphicMatcher<internal::PropertyMatcher< 
+    Class, PropertyType, PropertyType (Class::*)() const> > 
+Property(const std::string& property_name, 
+         PropertyType (Class::*property)() const, 
+         const PropertyMatcher& matcher) { 
+  return MakePolymorphicMatcher( 
+      internal::PropertyMatcher<Class, PropertyType, 
+                                PropertyType (Class::*)() const>( 
+          property_name, property, MatcherCast<const PropertyType&>(matcher))); 
+} 
+ 
+// The same as above but for reference-qualified member functions. 
+template <typename Class, typename PropertyType, typename PropertyMatcher> 
+inline PolymorphicMatcher<internal::PropertyMatcher< 
+    Class, PropertyType, PropertyType (Class::*)() const &> > 
+Property(PropertyType (Class::*property)() const &, 
+         const PropertyMatcher& matcher) { 
+  return MakePolymorphicMatcher( 
+      internal::PropertyMatcher<Class, PropertyType, 
+                                PropertyType (Class::*)() const&>( 
+          property, MatcherCast<const PropertyType&>(matcher))); 
+} 
+ 
+// Three-argument form for reference-qualified member functions. 
+template <typename Class, typename PropertyType, typename PropertyMatcher> 
+inline PolymorphicMatcher<internal::PropertyMatcher< 
+    Class, PropertyType, PropertyType (Class::*)() const &> > 
+Property(const std::string& property_name, 
+         PropertyType (Class::*property)() const &, 
+         const PropertyMatcher& matcher) { 
+  return MakePolymorphicMatcher( 
+      internal::PropertyMatcher<Class, PropertyType, 
+                                PropertyType (Class::*)() const&>( 
+          property_name, property, MatcherCast<const PropertyType&>(matcher))); 
+} 
+ 
+// Creates a matcher that matches an object if and only if the result of 
+// applying a callable to x matches 'matcher'. For example, 
 //   ResultOf(f, StartsWith("hi"))
-// matches a Foo object x if and only if f(x) starts with "hi".
-// `callable` parameter can be a function, function pointer, or a functor. It is
-// required to keep no state affecting the results of the calls on it and make
-// no assumptions about how many calls will be made. Any state it keeps must be
-// protected from the concurrent access.
-template <typename Callable, typename InnerMatcher>
-internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
-    Callable callable, InnerMatcher matcher) {
-  return internal::ResultOfMatcher<Callable, InnerMatcher>(
-      std::move(callable), std::move(matcher));
+// matches a Foo object x if and only if f(x) starts with "hi". 
+// `callable` parameter can be a function, function pointer, or a functor. It is 
+// required to keep no state affecting the results of the calls on it and make 
+// no assumptions about how many calls will be made. Any state it keeps must be 
+// protected from the concurrent access. 
+template <typename Callable, typename InnerMatcher> 
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf( 
+    Callable callable, InnerMatcher matcher) { 
+  return internal::ResultOfMatcher<Callable, InnerMatcher>( 
+      std::move(callable), std::move(matcher)); 
 }
 
 // String matchers.
 
 // Matches a string equal to str.
-template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
-    const internal::StringLike<T>& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq( 
+    const internal::StringLike<T>& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, true)); 
 }
 
 // Matches a string not equal to str.
-template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
-    const internal::StringLike<T>& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe( 
+    const internal::StringLike<T>& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::string>(std::string(str), false, true)); 
 }
 
 // Matches a string equal to str, ignoring case.
-template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
-    const internal::StringLike<T>& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq( 
+    const internal::StringLike<T>& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, false)); 
 }
 
 // Matches a string not equal to str, ignoring case.
-template <typename T = std::string>
-PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
-    const internal::StringLike<T>& str) {
-  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
-      std::string(str), false, false));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe( 
+    const internal::StringLike<T>& str) { 
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>( 
+      std::string(str), false, false)); 
 }
 
 // Creates a matcher that matches any string, std::string, or C string
 // that contains the given substring.
-template <typename T = std::string>
-PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
-    const internal::StringLike<T>& substring) {
-  return MakePolymorphicMatcher(
-      internal::HasSubstrMatcher<std::string>(std::string(substring)));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr( 
+    const internal::StringLike<T>& substring) { 
+  return MakePolymorphicMatcher( 
+      internal::HasSubstrMatcher<std::string>(std::string(substring))); 
 }
 
 // Matches a string that starts with 'prefix' (case-sensitive).
-template <typename T = std::string>
-PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
-    const internal::StringLike<T>& prefix) {
-  return MakePolymorphicMatcher(
-      internal::StartsWithMatcher<std::string>(std::string(prefix)));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith( 
+    const internal::StringLike<T>& prefix) { 
+  return MakePolymorphicMatcher( 
+      internal::StartsWithMatcher<std::string>(std::string(prefix))); 
 }
 
 // Matches a string that ends with 'suffix' (case-sensitive).
-template <typename T = std::string>
-PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
-    const internal::StringLike<T>& suffix) {
-  return MakePolymorphicMatcher(
-      internal::EndsWithMatcher<std::string>(std::string(suffix)));
+template <typename T = std::string> 
+PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith( 
+    const internal::StringLike<T>& suffix) { 
+  return MakePolymorphicMatcher( 
+      internal::EndsWithMatcher<std::string>(std::string(suffix))); 
 }
 
-#if GTEST_HAS_STD_WSTRING
+#if GTEST_HAS_STD_WSTRING 
 // Wide string matchers.
 
 // Matches a string equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq(
-    const std::wstring& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::wstring>(str, true, true));
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq( 
+    const std::wstring& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::wstring>(str, true, true)); 
 }
 
 // Matches a string not equal to str.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe(
-    const std::wstring& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::wstring>(str, false, true));
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe( 
+    const std::wstring& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::wstring>(str, false, true)); 
 }
 
 // Matches a string equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
-StrCaseEq(const std::wstring& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::wstring>(str, true, false));
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > 
+StrCaseEq(const std::wstring& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::wstring>(str, true, false)); 
 }
 
 // Matches a string not equal to str, ignoring case.
-inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
-StrCaseNe(const std::wstring& str) {
-  return MakePolymorphicMatcher(
-      internal::StrEqualityMatcher<std::wstring>(str, false, false));
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > 
+StrCaseNe(const std::wstring& str) { 
+  return MakePolymorphicMatcher( 
+      internal::StrEqualityMatcher<std::wstring>(str, false, false)); 
 }
 
-// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
+// Creates a matcher that matches any ::wstring, std::wstring, or C wide string 
 // that contains the given substring.
-inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr(
-    const std::wstring& substring) {
-  return MakePolymorphicMatcher(
-      internal::HasSubstrMatcher<std::wstring>(substring));
+inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr( 
+    const std::wstring& substring) { 
+  return MakePolymorphicMatcher( 
+      internal::HasSubstrMatcher<std::wstring>(substring)); 
 }
 
 // Matches a string that starts with 'prefix' (case-sensitive).
-inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
-StartsWith(const std::wstring& prefix) {
-  return MakePolymorphicMatcher(
-      internal::StartsWithMatcher<std::wstring>(prefix));
+inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> > 
+StartsWith(const std::wstring& prefix) { 
+  return MakePolymorphicMatcher( 
+      internal::StartsWithMatcher<std::wstring>(prefix)); 
 }
 
 // Matches a string that ends with 'suffix' (case-sensitive).
-inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
-    const std::wstring& suffix) {
-  return MakePolymorphicMatcher(
-      internal::EndsWithMatcher<std::wstring>(suffix));
+inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith( 
+    const std::wstring& suffix) { 
+  return MakePolymorphicMatcher( 
+      internal::EndsWithMatcher<std::wstring>(suffix)); 
 }
 
-#endif  // GTEST_HAS_STD_WSTRING
+#endif  // GTEST_HAS_STD_WSTRING 
 
 // Creates a polymorphic matcher that matches a 2-tuple where the
 // first field == the second field.
@@ -4421,58 +4421,58 @@ inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
 // first field != the second field.
 inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
 
-// Creates a polymorphic matcher that matches a 2-tuple where
-// FloatEq(first field) matches the second field.
-inline internal::FloatingEq2Matcher<float> FloatEq() {
-  return internal::FloatingEq2Matcher<float>();
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// DoubleEq(first field) matches the second field.
-inline internal::FloatingEq2Matcher<double> DoubleEq() {
-  return internal::FloatingEq2Matcher<double>();
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// FloatEq(first field) matches the second field with NaN equality.
-inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
-  return internal::FloatingEq2Matcher<float>(true);
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// DoubleEq(first field) matches the second field with NaN equality.
-inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
-  return internal::FloatingEq2Matcher<double>(true);
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// FloatNear(first field, max_abs_error) matches the second field.
-inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
-  return internal::FloatingEq2Matcher<float>(max_abs_error);
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// DoubleNear(first field, max_abs_error) matches the second field.
-inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {
-  return internal::FloatingEq2Matcher<double>(max_abs_error);
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// FloatNear(first field, max_abs_error) matches the second field with NaN
-// equality.
-inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
-    float max_abs_error) {
-  return internal::FloatingEq2Matcher<float>(max_abs_error, true);
-}
-
-// Creates a polymorphic matcher that matches a 2-tuple where
-// DoubleNear(first field, max_abs_error) matches the second field with NaN
-// equality.
-inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
-    double max_abs_error) {
-  return internal::FloatingEq2Matcher<double>(max_abs_error, true);
-}
-
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// FloatEq(first field) matches the second field. 
+inline internal::FloatingEq2Matcher<float> FloatEq() { 
+  return internal::FloatingEq2Matcher<float>(); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// DoubleEq(first field) matches the second field. 
+inline internal::FloatingEq2Matcher<double> DoubleEq() { 
+  return internal::FloatingEq2Matcher<double>(); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// FloatEq(first field) matches the second field with NaN equality. 
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() { 
+  return internal::FloatingEq2Matcher<float>(true); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// DoubleEq(first field) matches the second field with NaN equality. 
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() { 
+  return internal::FloatingEq2Matcher<double>(true); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// FloatNear(first field, max_abs_error) matches the second field. 
+inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) { 
+  return internal::FloatingEq2Matcher<float>(max_abs_error); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// DoubleNear(first field, max_abs_error) matches the second field. 
+inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) { 
+  return internal::FloatingEq2Matcher<double>(max_abs_error); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// FloatNear(first field, max_abs_error) matches the second field with NaN 
+// equality. 
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear( 
+    float max_abs_error) { 
+  return internal::FloatingEq2Matcher<float>(max_abs_error, true); 
+} 
+ 
+// Creates a polymorphic matcher that matches a 2-tuple where 
+// DoubleNear(first field, max_abs_error) matches the second field with NaN 
+// equality. 
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear( 
+    double max_abs_error) { 
+  return internal::FloatingEq2Matcher<double>(max_abs_error, true); 
+} 
+ 
 // Creates a matcher that matches any value of type T that m doesn't
 // match.
 template <typename InnerMatcher>
@@ -4517,10 +4517,10 @@ BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
 // values that are included in one container but not the other. (Duplicate
 // values and order differences are not explained.)
 template <typename Container>
-inline PolymorphicMatcher<internal::ContainerEqMatcher<
-    typename std::remove_const<Container>::type>>
-ContainerEq(const Container& rhs) {
-  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
+inline PolymorphicMatcher<internal::ContainerEqMatcher< 
+    typename std::remove_const<Container>::type>> 
+ContainerEq(const Container& rhs) { 
+  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs)); 
 }
 
 // Returns a matcher that matches a container that, when sorted using
@@ -4546,15 +4546,15 @@ WhenSorted(const ContainerMatcher& container_matcher) {
 // Matches an STL-style container or a native array that contains the
 // same number of elements as in rhs, where its i-th element and rhs's
 // i-th element (as a pair) satisfy the given pair matcher, for all i.
-// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
+// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const 
 // T1&, const T2&> >, where T1 and T2 are the types of elements in the
 // LHS container and the RHS container respectively.
 template <typename TupleMatcher, typename Container>
 inline internal::PointwiseMatcher<TupleMatcher,
-                                  typename std::remove_const<Container>::type>
+                                  typename std::remove_const<Container>::type> 
 Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
-  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,
-                                                             rhs);
+  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher, 
+                                                             rhs); 
 }
 
 
@@ -4571,7 +4571,7 @@ inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
 // elements as in rhs, where in some permutation of the container, its
 // i-th element and rhs's i-th element (as a pair) satisfy the given
 // pair matcher, for all i.  Tuple2Matcher must be able to be safely
-// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
+// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are 
 // the types of elements in the LHS container and the RHS container
 // respectively.
 //
@@ -4580,14 +4580,14 @@ inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
 template <typename Tuple2Matcher, typename RhsContainer>
 inline internal::UnorderedElementsAreArrayMatcher<
     typename internal::BoundSecondMatcher<
-        Tuple2Matcher,
-        typename internal::StlContainerView<
-            typename std::remove_const<RhsContainer>::type>::type::value_type>>
+        Tuple2Matcher, 
+        typename internal::StlContainerView< 
+            typename std::remove_const<RhsContainer>::type>::type::value_type>> 
 UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
                    const RhsContainer& rhs_container) {
   // RhsView allows the same code to handle RhsContainer being a
   // STL-style container and it being a native C-style array.
-  typedef typename internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename internal::StlContainerView<RhsContainer> RhsView; 
   typedef typename RhsView::type RhsStlContainer;
   typedef typename RhsStlContainer::value_type Second;
   const RhsStlContainer& rhs_stl_container =
@@ -4639,124 +4639,124 @@ inline internal::ContainsMatcher<M> Contains(M matcher) {
   return internal::ContainsMatcher<M>(matcher);
 }
 
-// IsSupersetOf(iterator_first, iterator_last)
-// IsSupersetOf(pointer, count)
-// IsSupersetOf(array)
-// IsSupersetOf(container)
-// IsSupersetOf({e1, e2, ..., en})
-//
-// IsSupersetOf() verifies that a surjective partial mapping onto a collection
-// of matchers exists. In other words, a container matches
-// IsSupersetOf({e1, ..., en}) if and only if there is a permutation
-// {y1, ..., yn} of some of the container's elements where y1 matches e1,
-// ..., and yn matches en. Obviously, the size of the container must be >= n
-// in order to have a match. Examples:
-//
-// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and
-//   1 matches Ne(0).
-// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
-//   both Eq(1) and Lt(2). The reason is that different matchers must be used
-//   for elements in different slots of the container.
-// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches
-//   Eq(1) and (the second) 1 matches Lt(2).
-// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)
-//   Gt(1) and 3 matches (the second) Gt(1).
-//
-// The matchers can be specified as an array, a pointer and count, a container,
-// an initializer list, or an STL iterator range. In each of these cases, the
-// underlying matchers can be either values or matchers.
-
-template <typename Iter>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-IsSupersetOf(Iter first, Iter last) {
-  typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::UnorderedElementsAreArrayMatcher<T>(
-      internal::UnorderedMatcherRequire::Superset, first, last);
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
-    const T* pointer, size_t count) {
-  return IsSupersetOf(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
-    const T (&array)[N]) {
-  return IsSupersetOf(array, N);
-}
-
-template <typename Container>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename Container::value_type>
-IsSupersetOf(const Container& container) {
-  return IsSupersetOf(container.begin(), container.end());
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
-    ::std::initializer_list<T> xs) {
-  return IsSupersetOf(xs.begin(), xs.end());
-}
-
-// IsSubsetOf(iterator_first, iterator_last)
-// IsSubsetOf(pointer, count)
-// IsSubsetOf(array)
-// IsSubsetOf(container)
-// IsSubsetOf({e1, e2, ..., en})
-//
-// IsSubsetOf() verifies that an injective mapping onto a collection of matchers
-// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and
-// only if there is a subset of matchers {m1, ..., mk} which would match the
-// container using UnorderedElementsAre.  Obviously, the size of the container
-// must be <= n in order to have a match. Examples:
-//
-// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).
-// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1
-//   matches Lt(0).
-// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
-//   match Gt(0). The reason is that different matchers must be used for
-//   elements in different slots of the container.
-//
-// The matchers can be specified as an array, a pointer and count, a container,
-// an initializer list, or an STL iterator range. In each of these cases, the
-// underlying matchers can be either values or matchers.
-
-template <typename Iter>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-IsSubsetOf(Iter first, Iter last) {
-  typedef typename ::std::iterator_traits<Iter>::value_type T;
-  return internal::UnorderedElementsAreArrayMatcher<T>(
-      internal::UnorderedMatcherRequire::Subset, first, last);
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
-    const T* pointer, size_t count) {
-  return IsSubsetOf(pointer, pointer + count);
-}
-
-template <typename T, size_t N>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
-    const T (&array)[N]) {
-  return IsSubsetOf(array, N);
-}
-
-template <typename Container>
-inline internal::UnorderedElementsAreArrayMatcher<
-    typename Container::value_type>
-IsSubsetOf(const Container& container) {
-  return IsSubsetOf(container.begin(), container.end());
-}
-
-template <typename T>
-inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
-    ::std::initializer_list<T> xs) {
-  return IsSubsetOf(xs.begin(), xs.end());
-}
-
+// IsSupersetOf(iterator_first, iterator_last) 
+// IsSupersetOf(pointer, count) 
+// IsSupersetOf(array) 
+// IsSupersetOf(container) 
+// IsSupersetOf({e1, e2, ..., en}) 
+// 
+// IsSupersetOf() verifies that a surjective partial mapping onto a collection 
+// of matchers exists. In other words, a container matches 
+// IsSupersetOf({e1, ..., en}) if and only if there is a permutation 
+// {y1, ..., yn} of some of the container's elements where y1 matches e1, 
+// ..., and yn matches en. Obviously, the size of the container must be >= n 
+// in order to have a match. Examples: 
+// 
+// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and 
+//   1 matches Ne(0). 
+// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches 
+//   both Eq(1) and Lt(2). The reason is that different matchers must be used 
+//   for elements in different slots of the container. 
+// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches 
+//   Eq(1) and (the second) 1 matches Lt(2). 
+// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first) 
+//   Gt(1) and 3 matches (the second) Gt(1). 
+// 
+// The matchers can be specified as an array, a pointer and count, a container, 
+// an initializer list, or an STL iterator range. In each of these cases, the 
+// underlying matchers can be either values or matchers. 
+ 
+template <typename Iter> 
+inline internal::UnorderedElementsAreArrayMatcher< 
+    typename ::std::iterator_traits<Iter>::value_type> 
+IsSupersetOf(Iter first, Iter last) { 
+  typedef typename ::std::iterator_traits<Iter>::value_type T; 
+  return internal::UnorderedElementsAreArrayMatcher<T>( 
+      internal::UnorderedMatcherRequire::Superset, first, last); 
+} 
+ 
+template <typename T> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( 
+    const T* pointer, size_t count) { 
+  return IsSupersetOf(pointer, pointer + count); 
+} 
+ 
+template <typename T, size_t N> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( 
+    const T (&array)[N]) { 
+  return IsSupersetOf(array, N); 
+} 
+ 
+template <typename Container> 
+inline internal::UnorderedElementsAreArrayMatcher< 
+    typename Container::value_type> 
+IsSupersetOf(const Container& container) { 
+  return IsSupersetOf(container.begin(), container.end()); 
+} 
+ 
+template <typename T> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( 
+    ::std::initializer_list<T> xs) { 
+  return IsSupersetOf(xs.begin(), xs.end()); 
+} 
+ 
+// IsSubsetOf(iterator_first, iterator_last) 
+// IsSubsetOf(pointer, count) 
+// IsSubsetOf(array) 
+// IsSubsetOf(container) 
+// IsSubsetOf({e1, e2, ..., en}) 
+// 
+// IsSubsetOf() verifies that an injective mapping onto a collection of matchers 
+// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and 
+// only if there is a subset of matchers {m1, ..., mk} which would match the 
+// container using UnorderedElementsAre.  Obviously, the size of the container 
+// must be <= n in order to have a match. Examples: 
+// 
+// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0). 
+// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1 
+//   matches Lt(0). 
+// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both 
+//   match Gt(0). The reason is that different matchers must be used for 
+//   elements in different slots of the container. 
+// 
+// The matchers can be specified as an array, a pointer and count, a container, 
+// an initializer list, or an STL iterator range. In each of these cases, the 
+// underlying matchers can be either values or matchers. 
+ 
+template <typename Iter> 
+inline internal::UnorderedElementsAreArrayMatcher< 
+    typename ::std::iterator_traits<Iter>::value_type> 
+IsSubsetOf(Iter first, Iter last) { 
+  typedef typename ::std::iterator_traits<Iter>::value_type T; 
+  return internal::UnorderedElementsAreArrayMatcher<T>( 
+      internal::UnorderedMatcherRequire::Subset, first, last); 
+} 
+ 
+template <typename T> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( 
+    const T* pointer, size_t count) { 
+  return IsSubsetOf(pointer, pointer + count); 
+} 
+ 
+template <typename T, size_t N> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( 
+    const T (&array)[N]) { 
+  return IsSubsetOf(array, N); 
+} 
+ 
+template <typename Container> 
+inline internal::UnorderedElementsAreArrayMatcher< 
+    typename Container::value_type> 
+IsSubsetOf(const Container& container) { 
+  return IsSubsetOf(container.begin(), container.end()); 
+} 
+ 
+template <typename T> 
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( 
+    ::std::initializer_list<T> xs) { 
+  return IsSubsetOf(xs.begin(), xs.end()); 
+} 
+ 
 // Matches an STL-style container or a native array that contains only
 // elements matching the given value or matcher.
 //
@@ -4809,35 +4809,35 @@ Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
       first_matcher, second_matcher);
 }
 
-namespace no_adl {
-// FieldsAre(matchers...) matches piecewise the fields of compatible structs.
-// These include those that support `get<I>(obj)`, and when structured bindings
-// are enabled any class that supports them.
-// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.
-template <typename... M>
-internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
-    M&&... matchers) {
-  return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
-      std::forward<M>(matchers)...);
-}
-
-// Creates a matcher that matches a pointer (raw or smart) that matches
-// inner_matcher.
-template <typename InnerMatcher>
-inline internal::PointerMatcher<InnerMatcher> Pointer(
-    const InnerMatcher& inner_matcher) {
-  return internal::PointerMatcher<InnerMatcher>(inner_matcher);
-}
-
-// Creates a matcher that matches an object that has an address that matches
-// inner_matcher.
-template <typename InnerMatcher>
-inline internal::AddressMatcher<InnerMatcher> Address(
-    const InnerMatcher& inner_matcher) {
-  return internal::AddressMatcher<InnerMatcher>(inner_matcher);
-}
-}  // namespace no_adl
-
+namespace no_adl { 
+// FieldsAre(matchers...) matches piecewise the fields of compatible structs. 
+// These include those that support `get<I>(obj)`, and when structured bindings 
+// are enabled any class that supports them. 
+// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types. 
+template <typename... M> 
+internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre( 
+    M&&... matchers) { 
+  return internal::FieldsAreMatcher<typename std::decay<M>::type...>( 
+      std::forward<M>(matchers)...); 
+} 
+ 
+// Creates a matcher that matches a pointer (raw or smart) that matches 
+// inner_matcher. 
+template <typename InnerMatcher> 
+inline internal::PointerMatcher<InnerMatcher> Pointer( 
+    const InnerMatcher& inner_matcher) { 
+  return internal::PointerMatcher<InnerMatcher>(inner_matcher); 
+} 
+ 
+// Creates a matcher that matches an object that has an address that matches 
+// inner_matcher. 
+template <typename InnerMatcher> 
+inline internal::AddressMatcher<InnerMatcher> Address( 
+    const InnerMatcher& inner_matcher) { 
+  return internal::AddressMatcher<InnerMatcher>(inner_matcher); 
+} 
+}  // namespace no_adl 
+ 
 // Returns a predicate that is satisfied by anything that matches the
 // given matcher.
 template <typename M>
@@ -4845,7 +4845,7 @@ inline internal::MatcherAsPredicate<M> Matches(M matcher) {
   return internal::MatcherAsPredicate<M>(matcher);
 }
 
-// Returns true if and only if the value matches the matcher.
+// Returns true if and only if the value matches the matcher. 
 template <typename T, typename M>
 inline bool Value(const T& value, M matcher) {
   return testing::Matches(matcher)(value);
@@ -4859,153 +4859,153 @@ inline bool ExplainMatchResult(
   return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
 }
 
-// Returns a string representation of the given matcher.  Useful for description
-// strings of matchers defined using MATCHER_P* macros that accept matchers as
-// their arguments.  For example:
-//
-// MATCHER_P(XAndYThat, matcher,
-//           "X that " + DescribeMatcher<int>(matcher, negation) +
-//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
-//   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
-//          ExplainMatchResult(matcher, arg.y(), result_listener);
-// }
-template <typename T, typename M>
-std::string DescribeMatcher(const M& matcher, bool negation = false) {
-  ::std::stringstream ss;
-  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);
-  if (negation) {
-    monomorphic_matcher.DescribeNegationTo(&ss);
-  } else {
-    monomorphic_matcher.DescribeTo(&ss);
-  }
-  return ss.str();
-}
-
-template <typename... Args>
-internal::ElementsAreMatcher<
-    std::tuple<typename std::decay<const Args&>::type...>>
-ElementsAre(const Args&... matchers) {
-  return internal::ElementsAreMatcher<
-      std::tuple<typename std::decay<const Args&>::type...>>(
-      std::make_tuple(matchers...));
-}
-
-template <typename... Args>
-internal::UnorderedElementsAreMatcher<
-    std::tuple<typename std::decay<const Args&>::type...>>
-UnorderedElementsAre(const Args&... matchers) {
-  return internal::UnorderedElementsAreMatcher<
-      std::tuple<typename std::decay<const Args&>::type...>>(
-      std::make_tuple(matchers...));
-}
-
-// Define variadic matcher versions.
+// Returns a string representation of the given matcher.  Useful for description 
+// strings of matchers defined using MATCHER_P* macros that accept matchers as 
+// their arguments.  For example: 
+// 
+// MATCHER_P(XAndYThat, matcher, 
+//           "X that " + DescribeMatcher<int>(matcher, negation) + 
+//               " and Y that " + DescribeMatcher<double>(matcher, negation)) { 
+//   return ExplainMatchResult(matcher, arg.x(), result_listener) && 
+//          ExplainMatchResult(matcher, arg.y(), result_listener); 
+// } 
+template <typename T, typename M> 
+std::string DescribeMatcher(const M& matcher, bool negation = false) { 
+  ::std::stringstream ss; 
+  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher); 
+  if (negation) { 
+    monomorphic_matcher.DescribeNegationTo(&ss); 
+  } else { 
+    monomorphic_matcher.DescribeTo(&ss); 
+  } 
+  return ss.str(); 
+} 
+ 
 template <typename... Args>
-internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
-    const Args&... matchers) {
-  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(
-      matchers...);
+internal::ElementsAreMatcher< 
+    std::tuple<typename std::decay<const Args&>::type...>> 
+ElementsAre(const Args&... matchers) { 
+  return internal::ElementsAreMatcher< 
+      std::tuple<typename std::decay<const Args&>::type...>>( 
+      std::make_tuple(matchers...)); 
 }
 
 template <typename... Args>
-internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(
-    const Args&... matchers) {
-  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(
-      matchers...);
-}
-
-// AnyOfArray(array)
-// AnyOfArray(pointer, count)
-// AnyOfArray(container)
-// AnyOfArray({ e1, e2, ..., en })
-// AnyOfArray(iterator_first, iterator_last)
-//
-// AnyOfArray() verifies whether a given value matches any member of a
-// collection of matchers.
-//
-// AllOfArray(array)
-// AllOfArray(pointer, count)
-// AllOfArray(container)
-// AllOfArray({ e1, e2, ..., en })
-// AllOfArray(iterator_first, iterator_last)
-//
-// AllOfArray() verifies whether a given value matches all members of a
-// collection of matchers.
-//
-// The matchers can be specified as an array, a pointer and count, a container,
-// an initializer list, or an STL iterator range. In each of these cases, the
-// underlying matchers can be either values or matchers.
-
-template <typename Iter>
-inline internal::AnyOfArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-AnyOfArray(Iter first, Iter last) {
-  return internal::AnyOfArrayMatcher<
-      typename ::std::iterator_traits<Iter>::value_type>(first, last);
-}
-
-template <typename Iter>
-inline internal::AllOfArrayMatcher<
-    typename ::std::iterator_traits<Iter>::value_type>
-AllOfArray(Iter first, Iter last) {
-  return internal::AllOfArrayMatcher<
-      typename ::std::iterator_traits<Iter>::value_type>(first, last);
-}
-
-template <typename T>
-inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {
-  return AnyOfArray(ptr, ptr + count);
-}
-
-template <typename T>
-inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {
-  return AllOfArray(ptr, ptr + count);
-}
-
-template <typename T, size_t N>
-inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
-  return AnyOfArray(array, N);
-}
-
-template <typename T, size_t N>
-inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
-  return AllOfArray(array, N);
-}
-
-template <typename Container>
-inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(
-    const Container& container) {
-  return AnyOfArray(container.begin(), container.end());
-}
-
-template <typename Container>
-inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(
-    const Container& container) {
-  return AllOfArray(container.begin(), container.end());
-}
-
-template <typename T>
-inline internal::AnyOfArrayMatcher<T> AnyOfArray(
-    ::std::initializer_list<T> xs) {
-  return AnyOfArray(xs.begin(), xs.end());
-}
-
-template <typename T>
-inline internal::AllOfArrayMatcher<T> AllOfArray(
-    ::std::initializer_list<T> xs) {
-  return AllOfArray(xs.begin(), xs.end());
-}
-
-// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
-// fields of it matches a_matcher.  C++ doesn't support default
-// arguments for function templates, so we have to overload it.
-template <size_t... k, typename InnerMatcher>
-internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
-    InnerMatcher&& matcher) {
-  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(
-      std::forward<InnerMatcher>(matcher));
-}
-
+internal::UnorderedElementsAreMatcher< 
+    std::tuple<typename std::decay<const Args&>::type...>> 
+UnorderedElementsAre(const Args&... matchers) { 
+  return internal::UnorderedElementsAreMatcher< 
+      std::tuple<typename std::decay<const Args&>::type...>>( 
+      std::make_tuple(matchers...)); 
+}
+
+// Define variadic matcher versions. 
+template <typename... Args> 
+internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf( 
+    const Args&... matchers) { 
+  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>( 
+      matchers...); 
+} 
+
+template <typename... Args> 
+internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf( 
+    const Args&... matchers) { 
+  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>( 
+      matchers...); 
+} 
+ 
+// AnyOfArray(array) 
+// AnyOfArray(pointer, count) 
+// AnyOfArray(container) 
+// AnyOfArray({ e1, e2, ..., en }) 
+// AnyOfArray(iterator_first, iterator_last) 
+// 
+// AnyOfArray() verifies whether a given value matches any member of a 
+// collection of matchers. 
+// 
+// AllOfArray(array) 
+// AllOfArray(pointer, count) 
+// AllOfArray(container) 
+// AllOfArray({ e1, e2, ..., en }) 
+// AllOfArray(iterator_first, iterator_last) 
+// 
+// AllOfArray() verifies whether a given value matches all members of a 
+// collection of matchers. 
+// 
+// The matchers can be specified as an array, a pointer and count, a container, 
+// an initializer list, or an STL iterator range. In each of these cases, the 
+// underlying matchers can be either values or matchers. 
+ 
+template <typename Iter> 
+inline internal::AnyOfArrayMatcher< 
+    typename ::std::iterator_traits<Iter>::value_type> 
+AnyOfArray(Iter first, Iter last) { 
+  return internal::AnyOfArrayMatcher< 
+      typename ::std::iterator_traits<Iter>::value_type>(first, last); 
+} 
+ 
+template <typename Iter> 
+inline internal::AllOfArrayMatcher< 
+    typename ::std::iterator_traits<Iter>::value_type> 
+AllOfArray(Iter first, Iter last) { 
+  return internal::AllOfArrayMatcher< 
+      typename ::std::iterator_traits<Iter>::value_type>(first, last); 
+} 
+ 
+template <typename T> 
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) { 
+  return AnyOfArray(ptr, ptr + count); 
+} 
+ 
+template <typename T> 
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) { 
+  return AllOfArray(ptr, ptr + count); 
+} 
+ 
+template <typename T, size_t N> 
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) { 
+  return AnyOfArray(array, N); 
+} 
+ 
+template <typename T, size_t N> 
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) { 
+  return AllOfArray(array, N); 
+} 
+ 
+template <typename Container> 
+inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray( 
+    const Container& container) { 
+  return AnyOfArray(container.begin(), container.end()); 
+} 
+ 
+template <typename Container> 
+inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray( 
+    const Container& container) { 
+  return AllOfArray(container.begin(), container.end()); 
+} 
+ 
+template <typename T> 
+inline internal::AnyOfArrayMatcher<T> AnyOfArray( 
+    ::std::initializer_list<T> xs) { 
+  return AnyOfArray(xs.begin(), xs.end()); 
+} 
+ 
+template <typename T> 
+inline internal::AllOfArrayMatcher<T> AllOfArray( 
+    ::std::initializer_list<T> xs) { 
+  return AllOfArray(xs.begin(), xs.end()); 
+} 
+ 
+// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected 
+// fields of it matches a_matcher.  C++ doesn't support default 
+// arguments for function templates, so we have to overload it. 
+template <size_t... k, typename InnerMatcher> 
+internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args( 
+    InnerMatcher&& matcher) { 
+  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>( 
+      std::forward<InnerMatcher>(matcher)); 
+} 
+ 
 // AllArgs(m) is a synonym of m.  This is useful in
 //
 //   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
@@ -5016,377 +5016,377 @@ internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
 template <typename InnerMatcher>
 inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
 
-// Returns a matcher that matches the value of an optional<> type variable.
-// The matcher implementation only uses '!arg' and requires that the optional<>
-// type has a 'value_type' member type and that '*arg' is of type 'value_type'
-// and is printable using 'PrintToString'. It is compatible with
-// std::optional/std::experimental::optional.
-// Note that to compare an optional type variable against nullopt you should
-// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the
-// optional value contains an optional itself.
-template <typename ValueMatcher>
-inline internal::OptionalMatcher<ValueMatcher> Optional(
-    const ValueMatcher& value_matcher) {
-  return internal::OptionalMatcher<ValueMatcher>(value_matcher);
-}
-
-// Returns a matcher that matches the value of a absl::any type variable.
-template <typename T>
-PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
-    const Matcher<const T&>& matcher) {
-  return MakePolymorphicMatcher(
-      internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
-}
-
-// Returns a matcher that matches the value of a variant<> type variable.
-// The matcher implementation uses ADL to find the holds_alternative and get
-// functions.
-// It is compatible with std::variant.
-template <typename T>
-PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith(
-    const Matcher<const T&>& matcher) {
-  return MakePolymorphicMatcher(
-      internal::variant_matcher::VariantMatcher<T>(matcher));
-}
-
-#if GTEST_HAS_EXCEPTIONS
-
-// Anything inside the `internal` namespace is internal to the implementation
-// and must not be used in user code!
-namespace internal {
-
-class WithWhatMatcherImpl {
- public:
-  WithWhatMatcherImpl(Matcher<std::string> matcher)
-      : matcher_(std::move(matcher)) {}
-
-  void DescribeTo(std::ostream* os) const {
-    *os << "contains .what() that ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << "contains .what() that does not ";
-    matcher_.DescribeTo(os);
-  }
-
-  template <typename Err>
-  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
-    *listener << "which contains .what() that ";
-    return matcher_.MatchAndExplain(err.what(), listener);
-  }
-
- private:
-  const Matcher<std::string> matcher_;
-};
-
-inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(
-    Matcher<std::string> m) {
-  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));
-}
-
-template <typename Err>
-class ExceptionMatcherImpl {
-  class NeverThrown {
-   public:
-    const char* what() const noexcept {
-      return "this exception should never be thrown";
-    }
-  };
-
-  // If the matchee raises an exception of a wrong type, we'd like to
-  // catch it and print its message and type. To do that, we add an additional
-  // catch clause:
-  //
-  //     try { ... }
-  //     catch (const Err&) { /* an expected exception */ }
-  //     catch (const std::exception&) { /* exception of a wrong type */ }
-  //
-  // However, if the `Err` itself is `std::exception`, we'd end up with two
-  // identical `catch` clauses:
-  //
-  //     try { ... }
-  //     catch (const std::exception&) { /* an expected exception */ }
-  //     catch (const std::exception&) { /* exception of a wrong type */ }
-  //
-  // This can cause a warning or an error in some compilers. To resolve
-  // the issue, we use a fake error type whenever `Err` is `std::exception`:
-  //
-  //     try { ... }
-  //     catch (const std::exception&) { /* an expected exception */ }
-  //     catch (const NeverThrown&) { /* exception of a wrong type */ }
-  using DefaultExceptionType = typename std::conditional<
-      std::is_same<typename std::remove_cv<
-                       typename std::remove_reference<Err>::type>::type,
-                   std::exception>::value,
-      const NeverThrown&, const std::exception&>::type;
-
- public:
-  ExceptionMatcherImpl(Matcher<const Err&> matcher)
-      : matcher_(std::move(matcher)) {}
-
-  void DescribeTo(std::ostream* os) const {
-    *os << "throws an exception which is a " << GetTypeName<Err>();
-    *os << " which ";
-    matcher_.DescribeTo(os);
-  }
-
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << "throws an exception which is not a " << GetTypeName<Err>();
-    *os << " which ";
-    matcher_.DescribeNegationTo(os);
-  }
-
-  template <typename T>
-  bool MatchAndExplain(T&& x, MatchResultListener* listener) const {
-    try {
-      (void)(std::forward<T>(x)());
-    } catch (const Err& err) {
-      *listener << "throws an exception which is a " << GetTypeName<Err>();
-      *listener << " ";
-      return matcher_.MatchAndExplain(err, listener);
-    } catch (DefaultExceptionType err) {
-#if GTEST_HAS_RTTI
-      *listener << "throws an exception of type " << GetTypeName(typeid(err));
-      *listener << " ";
-#else
-      *listener << "throws an std::exception-derived type ";
-#endif
-      *listener << "with description \"" << err.what() << "\"";
-      return false;
-    } catch (...) {
-      *listener << "throws an exception of an unknown type";
-      return false;
-    }
-
-    *listener << "does not throw any exception";
-    return false;
-  }
-
- private:
-  const Matcher<const Err&> matcher_;
-};
-
-}  // namespace internal
-
-// Throws()
-// Throws(exceptionMatcher)
-// ThrowsMessage(messageMatcher)
-//
-// This matcher accepts a callable and verifies that when invoked, it throws
-// an exception with the given type and properties.
-//
-// Examples:
-//
-//   EXPECT_THAT(
-//       []() { throw std::runtime_error("message"); },
-//       Throws<std::runtime_error>());
-//
-//   EXPECT_THAT(
-//       []() { throw std::runtime_error("message"); },
-//       ThrowsMessage<std::runtime_error>(HasSubstr("message")));
-//
-//   EXPECT_THAT(
-//       []() { throw std::runtime_error("message"); },
-//       Throws<std::runtime_error>(
-//           Property(&std::runtime_error::what, HasSubstr("message"))));
-
-template <typename Err>
-PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {
-  return MakePolymorphicMatcher(
-      internal::ExceptionMatcherImpl<Err>(A<const Err&>()));
-}
-
-template <typename Err, typename ExceptionMatcher>
-PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(
-    const ExceptionMatcher& exception_matcher) {
-  // Using matcher cast allows users to pass a matcher of a more broad type.
-  // For example user may want to pass Matcher<std::exception>
-  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.
-  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(
-      SafeMatcherCast<const Err&>(exception_matcher)));
-}
-
-template <typename Err, typename MessageMatcher>
-PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
-    MessageMatcher&& message_matcher) {
-  static_assert(std::is_base_of<std::exception, Err>::value,
-                "expected an std::exception-derived type");
-  return Throws<Err>(internal::WithWhat(
-      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));
-}
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
+// Returns a matcher that matches the value of an optional<> type variable. 
+// The matcher implementation only uses '!arg' and requires that the optional<> 
+// type has a 'value_type' member type and that '*arg' is of type 'value_type' 
+// and is printable using 'PrintToString'. It is compatible with 
+// std::optional/std::experimental::optional. 
+// Note that to compare an optional type variable against nullopt you should 
+// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the 
+// optional value contains an optional itself. 
+template <typename ValueMatcher> 
+inline internal::OptionalMatcher<ValueMatcher> Optional( 
+    const ValueMatcher& value_matcher) { 
+  return internal::OptionalMatcher<ValueMatcher>(value_matcher); 
+} 
+ 
+// Returns a matcher that matches the value of a absl::any type variable. 
+template <typename T> 
+PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith( 
+    const Matcher<const T&>& matcher) { 
+  return MakePolymorphicMatcher( 
+      internal::any_cast_matcher::AnyCastMatcher<T>(matcher)); 
+} 
+ 
+// Returns a matcher that matches the value of a variant<> type variable. 
+// The matcher implementation uses ADL to find the holds_alternative and get 
+// functions. 
+// It is compatible with std::variant. 
+template <typename T> 
+PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith( 
+    const Matcher<const T&>& matcher) { 
+  return MakePolymorphicMatcher( 
+      internal::variant_matcher::VariantMatcher<T>(matcher)); 
+} 
+ 
+#if GTEST_HAS_EXCEPTIONS 
+ 
+// Anything inside the `internal` namespace is internal to the implementation 
+// and must not be used in user code! 
+namespace internal { 
+ 
+class WithWhatMatcherImpl { 
+ public: 
+  WithWhatMatcherImpl(Matcher<std::string> matcher) 
+      : matcher_(std::move(matcher)) {} 
+ 
+  void DescribeTo(std::ostream* os) const { 
+    *os << "contains .what() that "; 
+    matcher_.DescribeTo(os); 
+  } 
+ 
+  void DescribeNegationTo(std::ostream* os) const { 
+    *os << "contains .what() that does not "; 
+    matcher_.DescribeTo(os); 
+  } 
+ 
+  template <typename Err> 
+  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const { 
+    *listener << "which contains .what() that "; 
+    return matcher_.MatchAndExplain(err.what(), listener); 
+  } 
+ 
+ private: 
+  const Matcher<std::string> matcher_; 
+}; 
+ 
+inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat( 
+    Matcher<std::string> m) { 
+  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m))); 
+} 
+ 
+template <typename Err> 
+class ExceptionMatcherImpl { 
+  class NeverThrown { 
+   public: 
+    const char* what() const noexcept { 
+      return "this exception should never be thrown"; 
+    } 
+  }; 
+ 
+  // If the matchee raises an exception of a wrong type, we'd like to 
+  // catch it and print its message and type. To do that, we add an additional 
+  // catch clause: 
+  // 
+  //     try { ... } 
+  //     catch (const Err&) { /* an expected exception */ } 
+  //     catch (const std::exception&) { /* exception of a wrong type */ } 
+  // 
+  // However, if the `Err` itself is `std::exception`, we'd end up with two 
+  // identical `catch` clauses: 
+  // 
+  //     try { ... } 
+  //     catch (const std::exception&) { /* an expected exception */ } 
+  //     catch (const std::exception&) { /* exception of a wrong type */ } 
+  // 
+  // This can cause a warning or an error in some compilers. To resolve 
+  // the issue, we use a fake error type whenever `Err` is `std::exception`: 
+  // 
+  //     try { ... } 
+  //     catch (const std::exception&) { /* an expected exception */ } 
+  //     catch (const NeverThrown&) { /* exception of a wrong type */ } 
+  using DefaultExceptionType = typename std::conditional< 
+      std::is_same<typename std::remove_cv< 
+                       typename std::remove_reference<Err>::type>::type, 
+                   std::exception>::value, 
+      const NeverThrown&, const std::exception&>::type; 
+ 
+ public: 
+  ExceptionMatcherImpl(Matcher<const Err&> matcher) 
+      : matcher_(std::move(matcher)) {} 
+ 
+  void DescribeTo(std::ostream* os) const { 
+    *os << "throws an exception which is a " << GetTypeName<Err>(); 
+    *os << " which "; 
+    matcher_.DescribeTo(os); 
+  } 
+ 
+  void DescribeNegationTo(std::ostream* os) const { 
+    *os << "throws an exception which is not a " << GetTypeName<Err>(); 
+    *os << " which "; 
+    matcher_.DescribeNegationTo(os); 
+  } 
+ 
+  template <typename T> 
+  bool MatchAndExplain(T&& x, MatchResultListener* listener) const { 
+    try { 
+      (void)(std::forward<T>(x)()); 
+    } catch (const Err& err) { 
+      *listener << "throws an exception which is a " << GetTypeName<Err>(); 
+      *listener << " "; 
+      return matcher_.MatchAndExplain(err, listener); 
+    } catch (DefaultExceptionType err) { 
+#if GTEST_HAS_RTTI 
+      *listener << "throws an exception of type " << GetTypeName(typeid(err)); 
+      *listener << " "; 
+#else 
+      *listener << "throws an std::exception-derived type "; 
+#endif 
+      *listener << "with description \"" << err.what() << "\""; 
+      return false; 
+    } catch (...) { 
+      *listener << "throws an exception of an unknown type"; 
+      return false; 
+    } 
+ 
+    *listener << "does not throw any exception"; 
+    return false; 
+  } 
+ 
+ private: 
+  const Matcher<const Err&> matcher_; 
+}; 
+ 
+}  // namespace internal 
+ 
+// Throws() 
+// Throws(exceptionMatcher) 
+// ThrowsMessage(messageMatcher) 
+// 
+// This matcher accepts a callable and verifies that when invoked, it throws 
+// an exception with the given type and properties. 
+// 
+// Examples: 
+// 
+//   EXPECT_THAT( 
+//       []() { throw std::runtime_error("message"); }, 
+//       Throws<std::runtime_error>()); 
+// 
+//   EXPECT_THAT( 
+//       []() { throw std::runtime_error("message"); }, 
+//       ThrowsMessage<std::runtime_error>(HasSubstr("message"))); 
+// 
+//   EXPECT_THAT( 
+//       []() { throw std::runtime_error("message"); }, 
+//       Throws<std::runtime_error>( 
+//           Property(&std::runtime_error::what, HasSubstr("message")))); 
+ 
+template <typename Err> 
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() { 
+  return MakePolymorphicMatcher( 
+      internal::ExceptionMatcherImpl<Err>(A<const Err&>())); 
+} 
+ 
+template <typename Err, typename ExceptionMatcher> 
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws( 
+    const ExceptionMatcher& exception_matcher) { 
+  // Using matcher cast allows users to pass a matcher of a more broad type. 
+  // For example user may want to pass Matcher<std::exception> 
+  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>. 
+  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>( 
+      SafeMatcherCast<const Err&>(exception_matcher))); 
+} 
+ 
+template <typename Err, typename MessageMatcher> 
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage( 
+    MessageMatcher&& message_matcher) { 
+  static_assert(std::is_base_of<std::exception, Err>::value, 
+                "expected an std::exception-derived type"); 
+  return Throws<Err>(internal::WithWhat( 
+      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher)))); 
+} 
+ 
+#endif  // GTEST_HAS_EXCEPTIONS 
+ 
 // These macros allow using matchers to check values in Google Test
 // tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
-// succeed if and only if the value matches the matcher.  If the assertion
-// fails, the value and the description of the matcher will be printed.
+// succeed if and only if the value matches the matcher.  If the assertion 
+// fails, the value and the description of the matcher will be printed. 
 #define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
     ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
 #define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
     ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
 
-// MATCHER* macroses itself are listed below.
-#define MATCHER(name, description)                                             \
-  class name##Matcher                                                          \
-      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
-   public:                                                                     \
-    template <typename arg_type>                                               \
-    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
-     public:                                                                   \
-      gmock_Impl() {}                                                          \
-      bool MatchAndExplain(                                                    \
-          const arg_type& arg,                                                 \
-          ::testing::MatchResultListener* result_listener) const override;     \
-      void DescribeTo(::std::ostream* gmock_os) const override {               \
-        *gmock_os << FormatDescription(false);                                 \
-      }                                                                        \
-      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
-        *gmock_os << FormatDescription(true);                                  \
-      }                                                                        \
-                                                                               \
-     private:                                                                  \
-      ::std::string FormatDescription(bool negation) const {                   \
-        ::std::string gmock_description = (description);                       \
-        if (!gmock_description.empty()) {                                      \
-          return gmock_description;                                            \
-        }                                                                      \
-        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
-                                                             {});              \
-      }                                                                        \
-    };                                                                         \
-  };                                                                           \
-  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \
-  template <typename arg_type>                                                 \
-  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
-      const arg_type& arg,                                                     \
-      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
-      const
-
-#define MATCHER_P(name, p0, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0))
-#define MATCHER_P2(name, p0, p1, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1))
-#define MATCHER_P3(name, p0, p1, p2, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2))
-#define MATCHER_P4(name, p0, p1, p2, p3, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3))
-#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
-                         (p0, p1, p2, p3, p4))
-#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
-                         (p0, p1, p2, p3, p4, p5))
-#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
-                         (p0, p1, p2, p3, p4, p5, p6))
-#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
-                         (p0, p1, p2, p3, p4, p5, p6, p7))
-#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
-                         (p0, p1, p2, p3, p4, p5, p6, p7, p8))
-#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
-  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
-                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
-
-#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \
-  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
-  class full_name : public ::testing::internal::MatcherBaseImpl<               \
-                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
-   public:                                                                     \
-    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \
-    template <typename arg_type>                                               \
-    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
-     public:                                                                   \
-      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \
-          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \
-      bool MatchAndExplain(                                                    \
-          const arg_type& arg,                                                 \
-          ::testing::MatchResultListener* result_listener) const override;     \
-      void DescribeTo(::std::ostream* gmock_os) const override {               \
-        *gmock_os << FormatDescription(false);                                 \
-      }                                                                        \
-      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
-        *gmock_os << FormatDescription(true);                                  \
-      }                                                                        \
-      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \
-                                                                               \
-     private:                                                                  \
-      ::std::string FormatDescription(bool negation) const {                   \
-        ::std::string gmock_description = (description);                       \
-        if (!gmock_description.empty()) {                                      \
-          return gmock_description;                                            \
-        }                                                                      \
-        return ::testing::internal::FormatMatcherDescription(                  \
-            negation, #name,                                                   \
-            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
-                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
-                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
-      }                                                                        \
-    };                                                                         \
-  };                                                                           \
-  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
-  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \
-      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \
-    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \
-        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \
-  }                                                                            \
-  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
-  template <typename arg_type>                                                 \
-  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \
-      arg_type>::MatchAndExplain(const arg_type& arg,                          \
-                                 ::testing::MatchResultListener*               \
-                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \
-      const
-
-#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
-  GMOCK_PP_TAIL(                                     \
-      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))
-#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \
-  , typename arg##_type
-
-#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))
-#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \
-  , arg##_type
-
-#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \
-  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \
-      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))
-#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \
-  , arg##_type gmock_p##i
-
-#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))
-#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \
-  , arg(::std::forward<arg##_type>(gmock_p##i))
-
-#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \
-  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)
-#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \
-  const arg##_type arg;
-
-#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))
-#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg
-
-#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
-  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
-#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
-  , gmock_p##i
-
-// To prevent ADL on certain functions we put them on a separate namespace.
-using namespace no_adl;  // NOLINT
-
+// MATCHER* macroses itself are listed below. 
+#define MATCHER(name, description)                                             \ 
+  class name##Matcher                                                          \ 
+      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \ 
+   public:                                                                     \ 
+    template <typename arg_type>                                               \ 
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \ 
+     public:                                                                   \ 
+      gmock_Impl() {}                                                          \ 
+      bool MatchAndExplain(                                                    \ 
+          const arg_type& arg,                                                 \ 
+          ::testing::MatchResultListener* result_listener) const override;     \ 
+      void DescribeTo(::std::ostream* gmock_os) const override {               \ 
+        *gmock_os << FormatDescription(false);                                 \ 
+      }                                                                        \ 
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \ 
+        *gmock_os << FormatDescription(true);                                  \ 
+      }                                                                        \ 
+                                                                               \ 
+     private:                                                                  \ 
+      ::std::string FormatDescription(bool negation) const {                   \ 
+        ::std::string gmock_description = (description);                       \ 
+        if (!gmock_description.empty()) {                                      \ 
+          return gmock_description;                                            \ 
+        }                                                                      \ 
+        return ::testing::internal::FormatMatcherDescription(negation, #name,  \ 
+                                                             {});              \ 
+      }                                                                        \ 
+    };                                                                         \ 
+  };                                                                           \ 
+  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \ 
+  template <typename arg_type>                                                 \ 
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \ 
+      const arg_type& arg,                                                     \ 
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \ 
+      const 
+ 
+#define MATCHER_P(name, p0, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0)) 
+#define MATCHER_P2(name, p0, p1, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1)) 
+#define MATCHER_P3(name, p0, p1, p2, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2)) 
+#define MATCHER_P4(name, p0, p1, p2, p3, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3)) 
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \ 
+                         (p0, p1, p2, p3, p4)) 
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \ 
+                         (p0, p1, p2, p3, p4, p5)) 
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \ 
+                         (p0, p1, p2, p3, p4, p5, p6)) 
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \ 
+                         (p0, p1, p2, p3, p4, p5, p6, p7)) 
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \ 
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8)) 
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \ 
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \ 
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) 
+ 
+#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \ 
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \ 
+  class full_name : public ::testing::internal::MatcherBaseImpl<               \ 
+                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \ 
+   public:                                                                     \ 
+    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \ 
+    template <typename arg_type>                                               \ 
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \ 
+     public:                                                                   \ 
+      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \ 
+          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \ 
+      bool MatchAndExplain(                                                    \ 
+          const arg_type& arg,                                                 \ 
+          ::testing::MatchResultListener* result_listener) const override;     \ 
+      void DescribeTo(::std::ostream* gmock_os) const override {               \ 
+        *gmock_os << FormatDescription(false);                                 \ 
+      }                                                                        \ 
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \ 
+        *gmock_os << FormatDescription(true);                                  \ 
+      }                                                                        \ 
+      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \ 
+                                                                               \ 
+     private:                                                                  \ 
+      ::std::string FormatDescription(bool negation) const {                   \ 
+        ::std::string gmock_description = (description);                       \ 
+        if (!gmock_description.empty()) {                                      \ 
+          return gmock_description;                                            \ 
+        }                                                                      \ 
+        return ::testing::internal::FormatMatcherDescription(                  \ 
+            negation, #name,                                                   \ 
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \ 
+                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \ 
+                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \ 
+      }                                                                        \ 
+    };                                                                         \ 
+  };                                                                           \ 
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \ 
+  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \ 
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \ 
+    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \ 
+        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \ 
+  }                                                                            \ 
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \ 
+  template <typename arg_type>                                                 \ 
+  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \ 
+      arg_type>::MatchAndExplain(const arg_type& arg,                          \ 
+                                 ::testing::MatchResultListener*               \ 
+                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \ 
+      const 
+ 
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \ 
+  GMOCK_PP_TAIL(                                     \ 
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args)) 
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \ 
+  , typename arg##_type 
+ 
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args)) 
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \ 
+  , arg##_type 
+ 
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \ 
+  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \ 
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args)) 
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \ 
+  , arg##_type gmock_p##i 
+ 
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args)) 
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \ 
+  , arg(::std::forward<arg##_type>(gmock_p##i)) 
+ 
+#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \ 
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args) 
+#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \ 
+  const arg##_type arg; 
+ 
+#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args)) 
+#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg 
+ 
+#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \ 
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args)) 
+#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \ 
+  , gmock_p##i 
+ 
+// To prevent ADL on certain functions we put them on a separate namespace. 
+using namespace no_adl;  // NOLINT 
+ 
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
-
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046 
+ 
 // Include any custom callback matchers added by the local installation.
 // We must include this header at the end to make sure it can use the
 // declarations from this file.
 #include "gmock/internal/custom/gmock-matchers.h"
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-actions.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-actions.h
index fd293358a2..1712771ffe 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-actions.h
@@ -27,468 +27,468 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
-// This file implements some commonly used variadic actions.
+// This file implements some commonly used variadic actions. 
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ 
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#include <memory> 
+#include <utility> 
 
-#include <memory>
-#include <utility>
+#include "gmock/gmock-actions.h" 
+#include "gmock/internal/gmock-port.h" 
 
-#include "gmock/gmock-actions.h"
-#include "gmock/internal/gmock-port.h"
+// Include any custom callback actions added by the local installation. 
+#include "gmock/internal/custom/gmock-generated-actions.h" 
 
-// Include any custom callback actions added by the local installation.
-#include "gmock/internal/custom/gmock-generated-actions.h"
+// Sometimes you want to give an action explicit template parameters 
+// that cannot be inferred from its value parameters.  ACTION() and 
+// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that 
+// and can be viewed as an extension to ACTION() and ACTION_P*(). 
+// 
+// The syntax: 
+// 
+//   ACTION_TEMPLATE(ActionName, 
+//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), 
+//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } 
+// 
+// defines an action template that takes m explicit template 
+// parameters and n value parameters.  name_i is the name of the i-th 
+// template parameter, and kind_i specifies whether it's a typename, 
+// an integral constant, or a template.  p_i is the name of the i-th 
+// value parameter. 
+// 
+// Example: 
+// 
+//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock 
+//   // function to type T and copies it to *output. 
+//   ACTION_TEMPLATE(DuplicateArg, 
+//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T), 
+//                   AND_1_VALUE_PARAMS(output)) { 
+//     *output = T(::std::get<k>(args)); 
+//   } 
+//   ... 
+//     int n; 
+//     EXPECT_CALL(mock, Foo(_, _)) 
+//         .WillOnce(DuplicateArg<1, unsigned char>(&n)); 
+// 
+// To create an instance of an action template, write: 
+// 
+//   ActionName<t1, ..., t_m>(v1, ..., v_n) 
+// 
+// where the ts are the template arguments and the vs are the value 
+// arguments.  The value argument types are inferred by the compiler. 
+// If you want to explicitly specify the value argument types, you can 
+// provide additional template arguments: 
+// 
+//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n) 
+// 
+// where u_i is the desired type of v_i. 
+// 
+// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the 
+// number of value parameters, but not on the number of template 
+// parameters.  Without the restriction, the meaning of the following 
+// is unclear: 
+// 
+//   OverloadedAction<int, bool>(x); 
+// 
+// Are we using a single-template-parameter action where 'bool' refers 
+// to the type of x, or are we using a two-template-parameter action 
+// where the compiler is asked to infer the type of x? 
+// 
+// Implementation notes: 
+// 
+// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and 
+// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for 
+// implementing ACTION_TEMPLATE.  The main trick we use is to create 
+// new macro invocations when expanding a macro.  For example, we have 
+// 
+//   #define ACTION_TEMPLATE(name, template_params, value_params) 
+//       ... GMOCK_INTERNAL_DECL_##template_params ... 
+// 
+// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) 
+// to expand to 
+// 
+//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... 
+// 
+// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the 
+// preprocessor will continue to expand it to 
+// 
+//       ... typename T ... 
+// 
+// This technique conforms to the C++ standard and is portable.  It 
+// allows us to implement action templates using O(N) code, where N is 
+// the maximum number of template/value parameters supported.  Without 
+// using it, we'd have to devote O(N^2) amount of code to implement all 
+// combinations of m and n. 
 
-// Sometimes you want to give an action explicit template parameters
-// that cannot be inferred from its value parameters.  ACTION() and
-// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
-// and can be viewed as an extension to ACTION() and ACTION_P*().
-//
-// The syntax:
-//
-//   ACTION_TEMPLATE(ActionName,
-//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
-//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
-//
-// defines an action template that takes m explicit template
-// parameters and n value parameters.  name_i is the name of the i-th
-// template parameter, and kind_i specifies whether it's a typename,
-// an integral constant, or a template.  p_i is the name of the i-th
-// value parameter.
-//
-// Example:
-//
-//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
-//   // function to type T and copies it to *output.
-//   ACTION_TEMPLATE(DuplicateArg,
-//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
-//                   AND_1_VALUE_PARAMS(output)) {
-//     *output = T(::std::get<k>(args));
-//   }
-//   ...
-//     int n;
-//     EXPECT_CALL(mock, Foo(_, _))
-//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
-//
-// To create an instance of an action template, write:
-//
-//   ActionName<t1, ..., t_m>(v1, ..., v_n)
-//
-// where the ts are the template arguments and the vs are the value
-// arguments.  The value argument types are inferred by the compiler.
-// If you want to explicitly specify the value argument types, you can
-// provide additional template arguments:
-//
-//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
-//
-// where u_i is the desired type of v_i.
-//
-// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
-// number of value parameters, but not on the number of template
-// parameters.  Without the restriction, the meaning of the following
-// is unclear:
-//
-//   OverloadedAction<int, bool>(x);
-//
-// Are we using a single-template-parameter action where 'bool' refers
-// to the type of x, or are we using a two-template-parameter action
-// where the compiler is asked to infer the type of x?
-//
-// Implementation notes:
-//
-// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
-// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
-// implementing ACTION_TEMPLATE.  The main trick we use is to create
-// new macro invocations when expanding a macro.  For example, we have
-//
-//   #define ACTION_TEMPLATE(name, template_params, value_params)
-//       ... GMOCK_INTERNAL_DECL_##template_params ...
-//
-// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
-// to expand to
-//
-//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
-//
-// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
-// preprocessor will continue to expand it to
-//
-//       ... typename T ...
-//
-// This technique conforms to the C++ standard and is portable.  It
-// allows us to implement action templates using O(N) code, where N is
-// the maximum number of template/value parameters supported.  Without
-// using it, we'd have to devote O(N^2) amount of code to implement all
-// combinations of m and n.
-
-// Declares the template parameters.
-#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
-#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) kind0 name0, kind1 name1
-#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) kind0 name0, kind1 name1, kind2 name2
-#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3
-#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
-    kind2 name2, kind3 name3, kind4 name4
-#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
-#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
-    kind5 name5, kind6 name6
-#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
-    kind4 name4, kind5 name5, kind6 name6, kind7 name7
-#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
-    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
-    kind8 name8
-#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
-    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
-    kind6 name6, kind7 name7, kind8 name8, kind9 name9
-
-// Lists the template parameters.
-#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
-#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1) name0, name1
-#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2) name0, name1, name2
-#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3) name0, name1, name2, name3
-#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
-    name4
-#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
-    name2, name3, name4, name5
-#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6) name0, name1, name2, name3, name4, name5, name6
-#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
-#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
-    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
-    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
-    name6, name7, name8
-#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
-    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
-    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
-    name3, name4, name5, name6, name7, name8, name9
-
-// Declares the types of value parameters.
-#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
-    typename p0##_type, typename p1##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
-    typename p0##_type, typename p1##_type, typename p2##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
-    typename p3##_type, typename p4##_type, typename p5##_type, \
-    typename p6##_type, typename p7##_type, typename p8##_type
-#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
-    typename p2##_type, typename p3##_type, typename p4##_type, \
-    typename p5##_type, typename p6##_type, typename p7##_type, \
-    typename p8##_type, typename p9##_type
-
-// Initializes the value parameters.
-#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
-    ()
-#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
-    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
-#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
-    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1))
-#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, \
-        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
-#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3))
-#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
-#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, \
-        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5))
-#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
-#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
-        p7(::std::move(gmock_p7))
-#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, \
-        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
-        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
-#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9)\
-    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
-        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
-        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
-        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
-        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
-        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
-        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
-        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
-        p9(::std::move(gmock_p9))
-
-// Defines the copy constructor
-#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
-    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
-#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default;
-#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default;
-
-// Declares the fields for storing the value parameters.
-#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
-#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
-    p1##_type p1;
-#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
-    p1##_type p1; p2##_type p2;
-#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
-    p1##_type p1; p2##_type p2; p3##_type p3;
-#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
-#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5;
-#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6;
-#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
-    p5##_type p5; p6##_type p6; p7##_type p7;
-#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
-#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
-    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
-    p9##_type p9;
-
-// Lists the value parameters.
-#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
-#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
-#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
-#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
-#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
-    p2, p3, p4
-#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
-    p1, p2, p3, p4, p5
-#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0, p1, p2, p3, p4, p5, p6
-#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0, p1, p2, p3, p4, p5, p6, p7
-#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
-#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
-
-// Lists the value parameter types.
-#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
-    p1##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
-    p1##_type, p2##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
-    p0##_type, p1##_type, p2##_type, p3##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
-    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
-    p6##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type
-#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
-    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
-
-// Declares the value parameters.
-#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
-#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
-    p1##_type p1
-#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
-    p1##_type p1, p2##_type p2
-#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
-    p1##_type p1, p2##_type p2, p3##_type p3
-#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
-    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
-#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
-    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5
-#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
-    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6
-#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
-    p5##_type p5, p6##_type p6, p7##_type p7
-#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
-#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
-    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
-    p9##_type p9
+// Declares the template parameters. 
+#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ 
+    name1) kind0 name0, kind1 name1 
+#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2) kind0 name0, kind1 name1, kind2 name2 
+#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \ 
+    kind3 name3 
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \ 
+    kind2 name2, kind3 name3, kind4 name4 
+#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \ 
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 
+    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ 
+    kind5 name5, kind6 name6 
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 
+    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \ 
+    kind4 name4, kind5 name5, kind6 name6, kind7 name7 
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 
+    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \ 
+    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \ 
+    kind8 name8 
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ 
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 
+    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \ 
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \ 
+    kind6 name6, kind7 name7, kind8 name8, kind9 name9 
 
-// The suffix of the class template implementing the action template.
-#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
-#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
-#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
-#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
-#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
-#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
-#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
-#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
-#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7) P8
-#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8) P9
-#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
-    p7, p8, p9) P10
-
-// The name of the class template implementing the action template.
-#define GMOCK_ACTION_CLASS_(name, value_params)\
-    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
-
-#define ACTION_TEMPLATE(name, template_params, value_params)                   \
-  template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  class GMOCK_ACTION_CLASS_(name, value_params) {                              \
-   public:                                                                     \
-    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
-        GMOCK_INTERNAL_DECL_##value_params)                                    \
-        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
-                    = default; ,                                               \
-                    : impl_(std::make_shared<gmock_Impl>(                      \
-                                GMOCK_INTERNAL_LIST_##value_params)) { })      \
-    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
-        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
-        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
-    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
-        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
-        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
-    template <typename F>                                                      \
-    operator ::testing::Action<F>() const {                                    \
-      return GMOCK_PP_IF(                                                      \
-          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
-                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
-                      (::testing::internal::MakeAction<F>(impl_)));            \
-    }                                                                          \
-   private:                                                                    \
-    class gmock_Impl {                                                         \
-     public:                                                                   \
-      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \
-      template <typename function_type, typename return_type,                  \
-                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
-      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
-      GMOCK_INTERNAL_DEFN_##value_params                                       \
-    };                                                                         \
-    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
-                , std::shared_ptr<const gmock_Impl> impl_;)                    \
-  };                                                                           \
-  template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  GMOCK_ACTION_CLASS_(name, value_params)<                                     \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
-          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \
-  template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
-          GMOCK_INTERNAL_DECL_##value_params) {                                \
-    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
-        GMOCK_INTERNAL_LIST_##template_params                                  \
-        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
-            GMOCK_INTERNAL_LIST_##value_params);                               \
-  }                                                                            \
-  template <GMOCK_INTERNAL_DECL_##template_params                              \
-            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
-  template <typename function_type, typename return_type, typename args_type,  \
-            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
-  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
-      GMOCK_INTERNAL_LIST_##template_params                                    \
-      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
-          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
-
-namespace testing {
+// Lists the template parameters. 
+#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ 
+    name1) name0, name1 
+#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2) name0, name1, name2 
+#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3) name0, name1, name2, name3 
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \ 
+    name4 
+#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \ 
+    name2, name3, name4, name5 
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 
+    name6) name0, name1, name2, name3, name4, name5, name6 
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 
+    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7 
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ 
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ 
+    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \ 
+    name6, name7, name8 
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ 
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ 
+    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \ 
+    name3, name4, name5, name6, name7, name8, name9 
 
+// Declares the types of value parameters. 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \ 
+    typename p0##_type, typename p1##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \ 
+    typename p0##_type, typename p1##_type, typename p2##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ 
+    typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ 
+    typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type, typename p4##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ 
+    typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type, typename p4##_type, typename p5##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type, typename p4##_type, typename p5##_type, \ 
+    typename p6##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type, typename p4##_type, typename p5##_type, \ 
+    typename p6##_type, typename p7##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \ 
+    typename p3##_type, typename p4##_type, typename p5##_type, \ 
+    typename p6##_type, typename p7##_type, typename p8##_type 
+#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \ 
+    typename p2##_type, typename p3##_type, typename p4##_type, \ 
+    typename p5##_type, typename p6##_type, typename p7##_type, \ 
+    typename p8##_type, typename p9##_type 
+ 
+// Initializes the value parameters. 
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\ 
+    () 
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\ 
+    (p0##_type gmock_p0) : p0(::std::move(gmock_p0)) 
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)) 
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, \ 
+        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) 
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)) 
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) 
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4, \ 
+        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ 
+        p5(::std::move(gmock_p5)) 
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 
+        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ 
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) 
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 
+        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ 
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ 
+        p7(::std::move(gmock_p7)) 
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 
+        p6##_type gmock_p6, p7##_type gmock_p7, \ 
+        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ 
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ 
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) 
+#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8, p9)\ 
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ 
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ 
+        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ 
+        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \ 
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ 
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ 
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ 
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \ 
+        p9(::std::move(gmock_p9)) 
+ 
+// Defines the copy constructor 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \ 
+    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default; 
+#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default; 
+ 
+// Declares the fields for storing the value parameters. 
+#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; 
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \ 
+    p1##_type p1; 
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \ 
+    p1##_type p1; p2##_type p2; 
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \ 
+    p1##_type p1; p2##_type p2; p3##_type p3; 
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ 
+    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; 
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ 
+    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 
+    p5##_type p5; 
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 
+    p5##_type p5; p6##_type p6; 
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ 
+    p5##_type p5; p6##_type p6; p7##_type p7; 
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ 
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; 
+#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ 
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \ 
+    p9##_type p9; 
+ 
+// Lists the value parameters. 
+#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 
+#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 
+#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 
+#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \ 
+    p2, p3, p4 
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \ 
+    p1, p2, p3, p4, p5 
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6) p0, p1, p2, p3, p4, p5, p6 
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7) p0, p1, p2, p3, p4, p5, p6, p7 
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8 
+#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 
+ 
+// Lists the value parameter types. 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \ 
+    p1##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \ 
+    p1##_type, p2##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ 
+    p0##_type, p1##_type, p2##_type, p3##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ 
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ 
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ 
+    p6##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 
+    p5##_type, p6##_type, p7##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 
+    p5##_type, p6##_type, p7##_type, p8##_type 
+#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ 
+    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type 
+ 
+// Declares the value parameters. 
+#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \ 
+    p1##_type p1 
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \ 
+    p1##_type p1, p2##_type p2 
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \ 
+    p1##_type p1, p2##_type p2, p3##_type p3 
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ 
+    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ 
+    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 
+    p5##_type p5 
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ 
+    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 
+    p5##_type p5, p6##_type p6 
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ 
+    p5##_type p5, p6##_type p6, p7##_type p7 
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 
+#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ 
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ 
+    p9##_type p9 
+ 
+// The suffix of the class template implementing the action template. 
+#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() 
+#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P 
+#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 
+#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 
+#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 
+#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 
+#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 
+#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 
+#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7) P8 
+#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8) P9 
+#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ 
+    p7, p8, p9) P10 
+ 
+// The name of the class template implementing the action template. 
+#define GMOCK_ACTION_CLASS_(name, value_params)\ 
+    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) 
+ 
+#define ACTION_TEMPLATE(name, template_params, value_params)                   \ 
+  template <GMOCK_INTERNAL_DECL_##template_params                              \ 
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \ 
+  class GMOCK_ACTION_CLASS_(name, value_params) {                              \ 
+   public:                                                                     \ 
+    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \ 
+        GMOCK_INTERNAL_DECL_##value_params)                                    \ 
+        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \ 
+                    = default; ,                                               \ 
+                    : impl_(std::make_shared<gmock_Impl>(                      \ 
+                                GMOCK_INTERNAL_LIST_##value_params)) { })      \ 
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \ 
+        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \ 
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \ 
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \ 
+        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \ 
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \ 
+    template <typename F>                                                      \ 
+    operator ::testing::Action<F>() const {                                    \ 
+      return GMOCK_PP_IF(                                                      \ 
+          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \ 
+                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \ 
+                      (::testing::internal::MakeAction<F>(impl_)));            \ 
+    }                                                                          \ 
+   private:                                                                    \ 
+    class gmock_Impl {                                                         \ 
+     public:                                                                   \ 
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \ 
+      template <typename function_type, typename return_type,                  \ 
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \ 
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \ 
+      GMOCK_INTERNAL_DEFN_##value_params                                       \ 
+    };                                                                         \ 
+    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \ 
+                , std::shared_ptr<const gmock_Impl> impl_;)                    \ 
+  };                                                                           \ 
+  template <GMOCK_INTERNAL_DECL_##template_params                              \ 
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \ 
+  GMOCK_ACTION_CLASS_(name, value_params)<                                     \ 
+      GMOCK_INTERNAL_LIST_##template_params                                    \ 
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \ 
+          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \ 
+  template <GMOCK_INTERNAL_DECL_##template_params                              \ 
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \ 
+  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \ 
+      GMOCK_INTERNAL_LIST_##template_params                                    \ 
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \ 
+          GMOCK_INTERNAL_DECL_##value_params) {                                \ 
+    return GMOCK_ACTION_CLASS_(name, value_params)<                            \ 
+        GMOCK_INTERNAL_LIST_##template_params                                  \ 
+        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \ 
+            GMOCK_INTERNAL_LIST_##value_params);                               \ 
+  }                                                                            \ 
+  template <GMOCK_INTERNAL_DECL_##template_params                              \ 
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \ 
+  template <typename function_type, typename return_type, typename args_type,  \ 
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \ 
+  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \ 
+      GMOCK_INTERNAL_LIST_##template_params                                    \ 
+      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \ 
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const 
+ 
+namespace testing { 
+ 
 // The ACTION*() macros trigger warning C4100 (unreferenced formal
 // parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
 // the macro definition, as the warnings are generated when the macro
@@ -499,69 +499,69 @@ namespace testing {
 # pragma warning(disable:4100)
 #endif
 
-namespace internal {
+namespace internal { 
 
-// internal::InvokeArgument - a helper for InvokeArgument action.
-// The basic overloads are provided here for generic functors.
-// Overloads for other custom-callables are provided in the
-// internal/custom/gmock-generated-actions.h header.
-template <typename F, typename... Args>
-auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
-  return f(args...);
+// internal::InvokeArgument - a helper for InvokeArgument action. 
+// The basic overloads are provided here for generic functors. 
+// Overloads for other custom-callables are provided in the 
+// internal/custom/gmock-generated-actions.h header. 
+template <typename F, typename... Args> 
+auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) { 
+  return f(args...); 
 }
 
-template <std::size_t index, typename... Params>
-struct InvokeArgumentAction {
-  template <typename... Args>
-  auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
-      std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
-      std::declval<const Params&>()...)) {
-    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{},
-                                              std::forward<Args>(args)...);
-    return params.Apply([&](const Params&... unpacked_params) {
-      auto&& callable = args_tuple.template Get<index>();
-      return internal::InvokeArgument(
-          std::forward<decltype(callable)>(callable), unpacked_params...);
-    });
-  }
+template <std::size_t index, typename... Params> 
+struct InvokeArgumentAction { 
+  template <typename... Args> 
+  auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument( 
+      std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)), 
+      std::declval<const Params&>()...)) { 
+    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{}, 
+                                              std::forward<Args>(args)...); 
+    return params.Apply([&](const Params&... unpacked_params) { 
+      auto&& callable = args_tuple.template Get<index>(); 
+      return internal::InvokeArgument( 
+          std::forward<decltype(callable)>(callable), unpacked_params...); 
+    }); 
+  } 
 
-  internal::FlatTuple<Params...> params;
-};
+  internal::FlatTuple<Params...> params; 
+}; 
 
-}  // namespace internal
+}  // namespace internal 
 
-// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
-// (0-based) argument, which must be a k-ary callable, of the mock
-// function, with arguments a1, a2, ..., a_k.
-//
-// Notes:
-//
-//   1. The arguments are passed by value by default.  If you need to
-//   pass an argument by reference, wrap it inside std::ref().  For
-//   example,
-//
-//     InvokeArgument<1>(5, string("Hello"), std::ref(foo))
-//
-//   passes 5 and string("Hello") by value, and passes foo by
-//   reference.
-//
-//   2. If the callable takes an argument by reference but std::ref() is
-//   not used, it will receive the reference to a copy of the value,
-//   instead of the original value.  For example, when the 0-th
-//   argument of the mock function takes a const string&, the action
-//
-//     InvokeArgument<0>(string("Hello"))
-//
-//   makes a copy of the temporary string("Hello") object and passes a
-//   reference of the copy, instead of the original temporary object,
-//   to the callable.  This makes it easy for a user to define an
-//   InvokeArgument action from temporary values and have it performed
-//   later.
-template <std::size_t index, typename... Params>
-internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
-InvokeArgument(Params&&... params) {
-  return {internal::FlatTuple<typename std::decay<Params>::type...>(
-      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th 
+// (0-based) argument, which must be a k-ary callable, of the mock 
+// function, with arguments a1, a2, ..., a_k. 
+// 
+// Notes: 
+// 
+//   1. The arguments are passed by value by default.  If you need to 
+//   pass an argument by reference, wrap it inside std::ref().  For 
+//   example, 
+// 
+//     InvokeArgument<1>(5, string("Hello"), std::ref(foo)) 
+// 
+//   passes 5 and string("Hello") by value, and passes foo by 
+//   reference. 
+// 
+//   2. If the callable takes an argument by reference but std::ref() is 
+//   not used, it will receive the reference to a copy of the value, 
+//   instead of the original value.  For example, when the 0-th 
+//   argument of the mock function takes a const string&, the action 
+// 
+//     InvokeArgument<0>(string("Hello")) 
+// 
+//   makes a copy of the temporary string("Hello") object and passes a 
+//   reference of the copy, instead of the original temporary object, 
+//   to the callable.  This makes it easy for a user to define an 
+//   InvokeArgument action from temporary values and have it performed 
+//   later. 
+template <std::size_t index, typename... Params> 
+internal::InvokeArgumentAction<index, typename std::decay<Params>::type...> 
+InvokeArgument(Params&&... params) { 
+  return {internal::FlatTuple<typename std::decay<Params>::type...>( 
+      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)}; 
 }
 
 #ifdef _MSC_VER
@@ -570,4 +570,4 @@ InvokeArgument(Params&&... params) {
 
 }  // namespace testing
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-matchers.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-matchers.h
index dfc77e359c..cfee28a1c7 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-matchers.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-more-matchers.h
@@ -27,35 +27,35 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
-// This file implements some matchers that depend on gmock-matchers.h.
+// This file implements some matchers that depend on gmock-matchers.h. 
 //
 // Note that tests are implemented in gmock-matchers_test.cc rather than
 // gmock-more-matchers-test.cc.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
 
-#include "gmock/gmock-matchers.h"
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ 
+ 
+#include "gmock/gmock-matchers.h" 
 
 namespace testing {
 
-// Silence C4100 (unreferenced formal
-// parameter) for MSVC
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-#if (_MSC_VER == 1900)
-// and silence C4800 (C4800: 'int *const ': forcing value
-// to bool 'true' or 'false') for MSVC 14
-# pragma warning(disable:4800)
-  #endif
-#endif
-
+// Silence C4100 (unreferenced formal 
+// parameter) for MSVC 
+#ifdef _MSC_VER 
+# pragma warning(push) 
+# pragma warning(disable:4100) 
+#if (_MSC_VER == 1900) 
+// and silence C4800 (C4800: 'int *const ': forcing value 
+// to bool 'true' or 'false') for MSVC 14 
+# pragma warning(disable:4800) 
+  #endif 
+#endif 
+ 
 // Defines a matcher that matches an empty container. The container must
 // support both size() and empty(), which all STL-like containers provide.
 MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
@@ -66,27 +66,27 @@ MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
   return false;
 }
 
-// Define a matcher that matches a value that evaluates in boolean
-// context to true.  Useful for types that define "explicit operator
-// bool" operators and so can't be compared for equality with true
-// and false.
-MATCHER(IsTrue, negation ? "is false" : "is true") {
-  return static_cast<bool>(arg);
-}
-
-// Define a matcher that matches a value that evaluates in boolean
-// context to false.  Useful for types that define "explicit operator
-// bool" operators and so can't be compared for equality with true
-// and false.
-MATCHER(IsFalse, negation ? "is true" : "is false") {
-  return !static_cast<bool>(arg);
-}
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-
+// Define a matcher that matches a value that evaluates in boolean 
+// context to true.  Useful for types that define "explicit operator 
+// bool" operators and so can't be compared for equality with true 
+// and false. 
+MATCHER(IsTrue, negation ? "is false" : "is true") { 
+  return static_cast<bool>(arg); 
+} 
+ 
+// Define a matcher that matches a value that evaluates in boolean 
+// context to false.  Useful for types that define "explicit operator 
+// bool" operators and so can't be compared for equality with true 
+// and false. 
+MATCHER(IsFalse, negation ? "is true" : "is false") { 
+  return !static_cast<bool>(arg); 
+} 
+ 
+#ifdef _MSC_VER 
+# pragma warning(pop) 
+#endif 
+ 
+ 
 }  // namespace testing
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-nice-strict.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-nice-strict.h
index b03b770c75..d902a780a5 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-nice-strict.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-nice-strict.h
@@ -1,261 +1,261 @@
-// Copyright 2008, 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.
-
-
-// Implements class templates NiceMock, NaggyMock, and StrictMock.
-//
-// Given a mock class MockFoo that is created using Google Mock,
-// NiceMock<MockFoo> is a subclass of MockFoo that allows
-// uninteresting calls (i.e. calls to mock methods that have no
-// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
-// that prints a warning when an uninteresting call occurs, and
-// StrictMock<MockFoo> is a subclass of MockFoo that treats all
-// uninteresting calls as errors.
-//
-// Currently a mock is naggy by default, so MockFoo and
-// NaggyMock<MockFoo> behave like the same.  However, we will soon
-// switch the default behavior of mocks to be nice, as that in general
-// leads to more maintainable tests.  When that happens, MockFoo will
-// stop behaving like NaggyMock<MockFoo> and start behaving like
-// NiceMock<MockFoo>.
-//
-// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
-// their respective base class.  Therefore you can write
-// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
-// has a constructor that accepts (int, const char*), for example.
-//
-// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
-// and StrictMock<MockFoo> only works for mock methods defined using
-// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
-// If a mock method is defined in a base class of MockFoo, the "nice"
-// or "strict" modifier may not affect it, depending on the compiler.
-// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
-// supported.
-
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
-
-#include <type_traits>
-
-#include "gmock/gmock-spec-builders.h"
-#include "gmock/internal/gmock-port.h"
-
-namespace testing {
-template <class MockClass>
-class NiceMock;
-template <class MockClass>
-class NaggyMock;
-template <class MockClass>
-class StrictMock;
-
-namespace internal {
-template <typename T>
-std::true_type StrictnessModifierProbe(const NiceMock<T>&);
-template <typename T>
-std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
-template <typename T>
-std::true_type StrictnessModifierProbe(const StrictMock<T>&);
-std::false_type StrictnessModifierProbe(...);
-
-template <typename T>
-constexpr bool HasStrictnessModifier() {
-  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
-}
-
-// Base classes that register and deregister with testing::Mock to alter the
-// default behavior around uninteresting calls. Inheriting from one of these
-// classes first and then MockClass ensures the MockClass constructor is run
-// after registration, and that the MockClass destructor runs before
-// deregistration. This guarantees that MockClass's constructor and destructor
-// run with the same level of strictness as its instance methods.
-
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
-    (defined(_MSC_VER) || defined(__clang__))
-// We need to mark these classes with this declspec to ensure that
-// the empty base class optimization is performed.
-#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
-#else
-#define GTEST_INTERNAL_EMPTY_BASE_CLASS
-#endif
-
-template <typename Base>
-class NiceMockImpl {
- public:
-  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
-
-  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
-};
-
-template <typename Base>
-class NaggyMockImpl {
- public:
-  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
-
-  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
-};
-
-template <typename Base>
-class StrictMockImpl {
- public:
-  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
-
-  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
-};
-
-}  // namespace internal
-
-template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
-    : private internal::NiceMockImpl<MockClass>,
-      public MockClass {
- public:
-  static_assert(!internal::HasStrictnessModifier<MockClass>(),
-                "Can't apply NiceMock to a class hierarchy that already has a "
-                "strictness modifier. See "
-                "https://google.github.io/googletest/"
-                "gmock_cook_book.html#NiceStrictNaggy");
-  NiceMock() : MockClass() {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  // Ideally, we would inherit base class's constructors through a using
-  // declaration, which would preserve their visibility. However, many existing
-  // tests rely on the fact that current implementation reexports protected
-  // constructors as public. These tests would need to be cleaned up first.
-
-  // Single argument constructor is special-cased so that it can be
-  // made explicit.
-  template <typename A>
-  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  template <typename TArg1, typename TArg2, typename... An>
-  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
-      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
-                  std::forward<An>(args)...) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
-};
-
-template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
-    : private internal::NaggyMockImpl<MockClass>,
-      public MockClass {
-  static_assert(!internal::HasStrictnessModifier<MockClass>(),
-                "Can't apply NaggyMock to a class hierarchy that already has a "
-                "strictness modifier. See "
-                "https://google.github.io/googletest/"
-                "gmock_cook_book.html#NiceStrictNaggy");
-
- public:
-  NaggyMock() : MockClass() {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  // Ideally, we would inherit base class's constructors through a using
-  // declaration, which would preserve their visibility. However, many existing
-  // tests rely on the fact that current implementation reexports protected
-  // constructors as public. These tests would need to be cleaned up first.
-
-  // Single argument constructor is special-cased so that it can be
-  // made explicit.
-  template <typename A>
-  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  template <typename TArg1, typename TArg2, typename... An>
-  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
-      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
-                  std::forward<An>(args)...) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
-};
-
-template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
-    : private internal::StrictMockImpl<MockClass>,
-      public MockClass {
- public:
-  static_assert(
-      !internal::HasStrictnessModifier<MockClass>(),
-      "Can't apply StrictMock to a class hierarchy that already has a "
-      "strictness modifier. See "
-      "https://google.github.io/googletest/"
-      "gmock_cook_book.html#NiceStrictNaggy");
-  StrictMock() : MockClass() {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  // Ideally, we would inherit base class's constructors through a using
-  // declaration, which would preserve their visibility. However, many existing
-  // tests rely on the fact that current implementation reexports protected
-  // constructors as public. These tests would need to be cleaned up first.
-
-  // Single argument constructor is special-cased so that it can be
-  // made explicit.
-  template <typename A>
-  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
-  template <typename TArg1, typename TArg2, typename... An>
-  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
-      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
-                  std::forward<An>(args)...) {
-    static_assert(sizeof(*this) == sizeof(MockClass),
-                  "The impl subclass shouldn't introduce any padding");
-  }
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
-};
-
-#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
-
-}  // namespace testing
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+// Copyright 2008, 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. 
+ 
+ 
+// Implements class templates NiceMock, NaggyMock, and StrictMock. 
+// 
+// Given a mock class MockFoo that is created using Google Mock, 
+// NiceMock<MockFoo> is a subclass of MockFoo that allows 
+// uninteresting calls (i.e. calls to mock methods that have no 
+// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo 
+// that prints a warning when an uninteresting call occurs, and 
+// StrictMock<MockFoo> is a subclass of MockFoo that treats all 
+// uninteresting calls as errors. 
+// 
+// Currently a mock is naggy by default, so MockFoo and 
+// NaggyMock<MockFoo> behave like the same.  However, we will soon 
+// switch the default behavior of mocks to be nice, as that in general 
+// leads to more maintainable tests.  When that happens, MockFoo will 
+// stop behaving like NaggyMock<MockFoo> and start behaving like 
+// NiceMock<MockFoo>. 
+// 
+// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of 
+// their respective base class.  Therefore you can write 
+// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo 
+// has a constructor that accepts (int, const char*), for example. 
+// 
+// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>, 
+// and StrictMock<MockFoo> only works for mock methods defined using 
+// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class. 
+// If a mock method is defined in a base class of MockFoo, the "nice" 
+// or "strict" modifier may not affect it, depending on the compiler. 
+// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT 
+// supported. 
+ 
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ 
+ 
+#include <type_traits> 
+ 
+#include "gmock/gmock-spec-builders.h" 
+#include "gmock/internal/gmock-port.h" 
+ 
+namespace testing { 
+template <class MockClass> 
+class NiceMock; 
+template <class MockClass> 
+class NaggyMock; 
+template <class MockClass> 
+class StrictMock; 
+ 
+namespace internal { 
+template <typename T> 
+std::true_type StrictnessModifierProbe(const NiceMock<T>&); 
+template <typename T> 
+std::true_type StrictnessModifierProbe(const NaggyMock<T>&); 
+template <typename T> 
+std::true_type StrictnessModifierProbe(const StrictMock<T>&); 
+std::false_type StrictnessModifierProbe(...); 
+ 
+template <typename T> 
+constexpr bool HasStrictnessModifier() { 
+  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value; 
+} 
+ 
+// Base classes that register and deregister with testing::Mock to alter the 
+// default behavior around uninteresting calls. Inheriting from one of these 
+// classes first and then MockClass ensures the MockClass constructor is run 
+// after registration, and that the MockClass destructor runs before 
+// deregistration. This guarantees that MockClass's constructor and destructor 
+// run with the same level of strictness as its instance methods. 
+ 
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \ 
+    (defined(_MSC_VER) || defined(__clang__)) 
+// We need to mark these classes with this declspec to ensure that 
+// the empty base class optimization is performed. 
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases) 
+#else 
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS 
+#endif 
+ 
+template <typename Base> 
+class NiceMockImpl { 
+ public: 
+  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); } 
+ 
+  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); } 
+}; 
+ 
+template <typename Base> 
+class NaggyMockImpl { 
+ public: 
+  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); } 
+ 
+  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); } 
+}; 
+ 
+template <typename Base> 
+class StrictMockImpl { 
+ public: 
+  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); } 
+ 
+  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); } 
+}; 
+ 
+}  // namespace internal 
+ 
+template <class MockClass> 
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock 
+    : private internal::NiceMockImpl<MockClass>, 
+      public MockClass { 
+ public: 
+  static_assert(!internal::HasStrictnessModifier<MockClass>(), 
+                "Can't apply NiceMock to a class hierarchy that already has a " 
+                "strictness modifier. See " 
+                "https://google.github.io/googletest/" 
+                "gmock_cook_book.html#NiceStrictNaggy"); 
+  NiceMock() : MockClass() { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  // Ideally, we would inherit base class's constructors through a using 
+  // declaration, which would preserve their visibility. However, many existing 
+  // tests rely on the fact that current implementation reexports protected 
+  // constructors as public. These tests would need to be cleaned up first. 
+ 
+  // Single argument constructor is special-cased so that it can be 
+  // made explicit. 
+  template <typename A> 
+  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  template <typename TArg1, typename TArg2, typename... An> 
+  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args) 
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), 
+                  std::forward<An>(args)...) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+ private: 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock); 
+}; 
+ 
+template <class MockClass> 
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock 
+    : private internal::NaggyMockImpl<MockClass>, 
+      public MockClass { 
+  static_assert(!internal::HasStrictnessModifier<MockClass>(), 
+                "Can't apply NaggyMock to a class hierarchy that already has a " 
+                "strictness modifier. See " 
+                "https://google.github.io/googletest/" 
+                "gmock_cook_book.html#NiceStrictNaggy"); 
+ 
+ public: 
+  NaggyMock() : MockClass() { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  // Ideally, we would inherit base class's constructors through a using 
+  // declaration, which would preserve their visibility. However, many existing 
+  // tests rely on the fact that current implementation reexports protected 
+  // constructors as public. These tests would need to be cleaned up first. 
+ 
+  // Single argument constructor is special-cased so that it can be 
+  // made explicit. 
+  template <typename A> 
+  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  template <typename TArg1, typename TArg2, typename... An> 
+  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args) 
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), 
+                  std::forward<An>(args)...) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+ private: 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock); 
+}; 
+ 
+template <class MockClass> 
+class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock 
+    : private internal::StrictMockImpl<MockClass>, 
+      public MockClass { 
+ public: 
+  static_assert( 
+      !internal::HasStrictnessModifier<MockClass>(), 
+      "Can't apply StrictMock to a class hierarchy that already has a " 
+      "strictness modifier. See " 
+      "https://google.github.io/googletest/" 
+      "gmock_cook_book.html#NiceStrictNaggy"); 
+  StrictMock() : MockClass() { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  // Ideally, we would inherit base class's constructors through a using 
+  // declaration, which would preserve their visibility. However, many existing 
+  // tests rely on the fact that current implementation reexports protected 
+  // constructors as public. These tests would need to be cleaned up first. 
+ 
+  // Single argument constructor is special-cased so that it can be 
+  // made explicit. 
+  template <typename A> 
+  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+  template <typename TArg1, typename TArg2, typename... An> 
+  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args) 
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2), 
+                  std::forward<An>(args)...) { 
+    static_assert(sizeof(*this) == sizeof(MockClass), 
+                  "The impl subclass shouldn't introduce any padding"); 
+  } 
+ 
+ private: 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock); 
+}; 
+ 
+#undef GTEST_INTERNAL_EMPTY_BASE_CLASS 
+ 
+}  // namespace testing 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock-spec-builders.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock-spec-builders.h
index 41323c1cc0..22c427de8c 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock-spec-builders.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock-spec-builders.h
@@ -27,7 +27,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements the ON_CALL() and EXPECT_CALL() macros.
@@ -56,19 +56,19 @@
 // where all clauses are optional, and .InSequence()/.After()/
 // .WillOnce() can appear any number of times.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ 
 
-#include <functional>
+#include <functional> 
 #include <map>
-#include <memory>
+#include <memory> 
 #include <set>
 #include <sstream>
 #include <string>
-#include <type_traits>
-#include <utility>
+#include <type_traits> 
+#include <utility> 
 #include <vector>
 #include "gmock/gmock-actions.h"
 #include "gmock/gmock-cardinalities.h"
@@ -77,13 +77,13 @@
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
 
-#if GTEST_HAS_EXCEPTIONS
-# include <stdexcept>  // NOLINT
-#endif
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+#if GTEST_HAS_EXCEPTIONS 
+# include <stdexcept>  // NOLINT 
+#endif 
+ 
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 
 // An abstract handle of an expectation.
@@ -108,14 +108,14 @@ template <typename F> class TypedExpectation;
 // Helper class for testing the Expectation class template.
 class ExpectationTester;
 
-// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
-template <typename MockClass>
-class NiceMockImpl;
-template <typename MockClass>
-class StrictMockImpl;
-template <typename MockClass>
-class NaggyMockImpl;
-
+// Helper classes for implementing NiceMock, StrictMock, and NaggyMock. 
+template <typename MockClass> 
+class NiceMockImpl; 
+template <typename MockClass> 
+class StrictMockImpl; 
+template <typename MockClass> 
+class NaggyMockImpl; 
+ 
 // Protects the mock object registry (in class Mock), all function
 // mockers, and all expectations.
 //
@@ -132,9 +132,9 @@ GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
 // Untyped base class for ActionResultHolder<R>.
 class UntypedActionResultHolderBase;
 
-// Abstract base class of FunctionMocker.  This is the
+// Abstract base class of FunctionMocker.  This is the 
 // type-agnostic part of the function mocker interface.  Its pure
-// virtual methods are implemented by FunctionMocker.
+// virtual methods are implemented by FunctionMocker. 
 class GTEST_API_ UntypedFunctionMockerBase {
  public:
   UntypedFunctionMockerBase();
@@ -160,13 +160,13 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // action fails.
   // L = *
   virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      void* untyped_args, const std::string& call_description) const = 0;
+      void* untyped_args, const std::string& call_description) const = 0; 
 
   // Performs the given action with the given arguments and returns
   // the action's result.
   // L = *
   virtual UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, void* untyped_args) const = 0;
+      const void* untyped_action, void* untyped_args) const = 0; 
 
   // Writes a message that the call is uninteresting (i.e. neither
   // explicitly expected nor explicitly unexpected) to the given
@@ -220,13 +220,13 @@ class GTEST_API_ UntypedFunctionMockerBase {
   // arguments.  This function can be safely called from multiple
   // threads concurrently.  The caller is responsible for deleting the
   // result.
-  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args) 
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex); 
 
  protected:
   typedef std::vector<const void*> UntypedOnCallSpecs;
 
-  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
+  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>; 
 
   // Returns an Expectation object that references and co-owns exp,
   // which must be an expectation on this mock function.
@@ -245,14 +245,14 @@ class GTEST_API_ UntypedFunctionMockerBase {
   UntypedOnCallSpecs untyped_on_call_specs_;
 
   // All expectations for this function mocker.
-  //
-  // It's undefined behavior to interleave expectations (EXPECT_CALLs
-  // or ON_CALLs) and mock function calls.  Also, the order of
-  // expectations is important.  Therefore it's a logic race condition
-  // to read/write untyped_expectations_ concurrently.  In order for
-  // tools like tsan to catch concurrent read/write accesses to
-  // untyped_expectations, we deliberately leave accesses to it
-  // unprotected.
+  // 
+  // It's undefined behavior to interleave expectations (EXPECT_CALLs 
+  // or ON_CALLs) and mock function calls.  Also, the order of 
+  // expectations is important.  Therefore it's a logic race condition 
+  // to read/write untyped_expectations_ concurrently.  In order for 
+  // tools like tsan to catch concurrent read/write accesses to 
+  // untyped_expectations, we deliberately leave accesses to it 
+  // unprotected. 
   UntypedExpectations untyped_expectations_;
 };  // class UntypedFunctionMockerBase
 
@@ -278,14 +278,14 @@ class UntypedOnCallSpecBase {
   };
 
   // Asserts that the ON_CALL() statement has a certain property.
-  void AssertSpecProperty(bool property,
-                          const std::string& failure_message) const {
+  void AssertSpecProperty(bool property, 
+                          const std::string& failure_message) const { 
     Assert(property, file_, line_, failure_message);
   }
 
   // Expects that the ON_CALL() statement has a certain property.
-  void ExpectSpecProperty(bool property,
-                          const std::string& failure_message) const {
+  void ExpectSpecProperty(bool property, 
+                          const std::string& failure_message) const { 
     Expect(property, file_, line_, failure_message);
   }
 
@@ -311,9 +311,9 @@ class OnCallSpec : public UntypedOnCallSpecBase {
       : UntypedOnCallSpecBase(a_file, a_line),
         matchers_(matchers),
         // By default, extra_matcher_ should match anything.  However,
-        // we cannot initialize it with _ as that causes ambiguity between
-        // Matcher's copy and move constructor for some argument types.
-        extra_matcher_(A<const ArgumentTuple&>()) {}
+        // we cannot initialize it with _ as that causes ambiguity between 
+        // Matcher's copy and move constructor for some argument types. 
+        extra_matcher_(A<const ArgumentTuple&>()) {} 
 
   // Implements the .With() clause.
   OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
@@ -340,7 +340,7 @@ class OnCallSpec : public UntypedOnCallSpecBase {
     return *this;
   }
 
-  // Returns true if and only if the given arguments match the matchers.
+  // Returns true if and only if the given arguments match the matchers. 
   bool Matches(const ArgumentTuple& args) const {
     return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
   }
@@ -398,35 +398,35 @@ class GTEST_API_ Mock {
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
   // Verifies all expectations on the given mock object and clears its
-  // default actions and expectations.  Returns true if and only if the
+  // default actions and expectations.  Returns true if and only if the 
   // verification was successful.
   static bool VerifyAndClear(void* mock_obj)
       GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
 
-  // Returns whether the mock was created as a naggy mock (default)
-  static bool IsNaggy(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-  // Returns whether the mock was created as a nice mock
-  static bool IsNice(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-  // Returns whether the mock was created as a strict mock
-  static bool IsStrict(void* mock_obj)
-      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
-
+  // Returns whether the mock was created as a naggy mock (default) 
+  static bool IsNaggy(void* mock_obj) 
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
+  // Returns whether the mock was created as a nice mock 
+  static bool IsNice(void* mock_obj) 
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
+  // Returns whether the mock was created as a strict mock 
+  static bool IsStrict(void* mock_obj) 
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex); 
+ 
  private:
   friend class internal::UntypedFunctionMockerBase;
 
   // Needed for a function mocker to register itself (so that we know
   // how to clear a mock object).
   template <typename F>
-  friend class internal::FunctionMocker;
+  friend class internal::FunctionMocker; 
 
-  template <typename MockClass>
-  friend class internal::NiceMockImpl;
-  template <typename MockClass>
-  friend class internal::NaggyMockImpl;
-  template <typename MockClass>
-  friend class internal::StrictMockImpl;
+  template <typename MockClass> 
+  friend class internal::NiceMockImpl; 
+  template <typename MockClass> 
+  friend class internal::NaggyMockImpl; 
+  template <typename MockClass> 
+  friend class internal::StrictMockImpl; 
 
   // Tells Google Mock to allow uninteresting calls on the given mock
   // object.
@@ -480,7 +480,7 @@ class GTEST_API_ Mock {
   // Unregisters a mock method; removes the owning mock object from
   // the registry when the last mock method associated with it has
   // been unregistered.  This is called only in the destructor of
-  // FunctionMocker.
+  // FunctionMocker. 
   static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
 };  // class Mock
@@ -500,15 +500,15 @@ class GTEST_API_ Mock {
 //   - Constness is shallow: a const Expectation object itself cannot
 //     be modified, but the mutable methods of the ExpectationBase
 //     object it references can be called via expectation_base().
-
+ 
 class GTEST_API_ Expectation {
  public:
   // Constructs a null object that doesn't reference any expectation.
   Expectation();
-  Expectation(Expectation&&) = default;
-  Expectation(const Expectation&) = default;
-  Expectation& operator=(Expectation&&) = default;
-  Expectation& operator=(const Expectation&) = default;
+  Expectation(Expectation&&) = default; 
+  Expectation(const Expectation&) = default; 
+  Expectation& operator=(Expectation&&) = default; 
+  Expectation& operator=(const Expectation&) = default; 
   ~Expectation();
 
   // This single-argument ctor must not be explicit, in order to support the
@@ -525,8 +525,8 @@ class GTEST_API_ Expectation {
   // The compiler-generated copy ctor and operator= work exactly as
   // intended, so we don't need to define our own.
 
-  // Returns true if and only if rhs references the same expectation as this
-  // object does.
+  // Returns true if and only if rhs references the same expectation as this 
+  // object does. 
   bool operator==(const Expectation& rhs) const {
     return expectation_base_ == rhs.expectation_base_;
   }
@@ -540,7 +540,7 @@ class GTEST_API_ Expectation {
   friend class ::testing::internal::UntypedFunctionMockerBase;
 
   template <typename F>
-  friend class ::testing::internal::FunctionMocker;
+  friend class ::testing::internal::FunctionMocker; 
 
   template <typename F>
   friend class ::testing::internal::TypedExpectation;
@@ -556,15 +556,15 @@ class GTEST_API_ Expectation {
   typedef ::std::set<Expectation, Less> Set;
 
   Expectation(
-      const std::shared_ptr<internal::ExpectationBase>& expectation_base);
+      const std::shared_ptr<internal::ExpectationBase>& expectation_base); 
 
   // Returns the expectation this object references.
-  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
+  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const { 
     return expectation_base_;
   }
 
-  // A shared_ptr that co-owns the expectation this handle references.
-  std::shared_ptr<internal::ExpectationBase> expectation_base_;
+  // A shared_ptr that co-owns the expectation this handle references. 
+  std::shared_ptr<internal::ExpectationBase> expectation_base_; 
 };
 
 // A set of expectation handles.  Useful in the .After() clause of
@@ -608,8 +608,8 @@ class ExpectationSet {
   // The compiler-generator ctor and operator= works exactly as
   // intended, so we don't need to define our own.
 
-  // Returns true if and only if rhs contains the same set of Expectation
-  // objects as this does.
+  // Returns true if and only if rhs contains the same set of Expectation 
+  // objects as this does. 
   bool operator==(const ExpectationSet& rhs) const {
     return expectations_ == rhs.expectations_;
   }
@@ -646,8 +646,8 @@ class GTEST_API_ Sequence {
   void AddExpectation(const Expectation& expectation) const;
 
  private:
-  // The last expectation in this sequence.
-  std::shared_ptr<Expectation> last_expectation_;
+  // The last expectation in this sequence. 
+  std::shared_ptr<Expectation> last_expectation_; 
 };  // class Sequence
 
 // An object of this type causes all EXPECT_CALL() statements
@@ -707,7 +707,7 @@ GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
 class GTEST_API_ ExpectationBase {
  public:
   // source_text is the EXPECT_CALL(...) source that created this Expectation.
-  ExpectationBase(const char* file, int line, const std::string& source_text);
+  ExpectationBase(const char* file, int line, const std::string& source_text); 
 
   virtual ~ExpectationBase();
 
@@ -755,14 +755,14 @@ class GTEST_API_ ExpectationBase {
   virtual Expectation GetHandle() = 0;
 
   // Asserts that the EXPECT_CALL() statement has the given property.
-  void AssertSpecProperty(bool property,
-                          const std::string& failure_message) const {
+  void AssertSpecProperty(bool property, 
+                          const std::string& failure_message) const { 
     Assert(property, file_, line_, failure_message);
   }
 
   // Expects that the EXPECT_CALL() statement has the given property.
-  void ExpectSpecProperty(bool property,
-                          const std::string& failure_message) const {
+  void ExpectSpecProperty(bool property, 
+                          const std::string& failure_message) const { 
     Expect(property, file_, line_, failure_message);
   }
 
@@ -770,8 +770,8 @@ class GTEST_API_ ExpectationBase {
   // by the subclasses to implement the .Times() clause.
   void SpecifyCardinality(const Cardinality& cardinality);
 
-  // Returns true if and only if the user specified the cardinality
-  // explicitly using a .Times().
+  // Returns true if and only if the user specified the cardinality 
+  // explicitly using a .Times(). 
   bool cardinality_specified() const { return cardinality_specified_; }
 
   // Sets the cardinality of this expectation spec.
@@ -787,7 +787,7 @@ class GTEST_API_ ExpectationBase {
   void RetireAllPreRequisites()
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
 
-  // Returns true if and only if this expectation is retired.
+  // Returns true if and only if this expectation is retired. 
   bool is_retired() const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
@@ -801,29 +801,29 @@ class GTEST_API_ ExpectationBase {
     retired_ = true;
   }
 
-  // Returns true if and only if this expectation is satisfied.
+  // Returns true if and only if this expectation is satisfied. 
   bool IsSatisfied() const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsSatisfiedByCallCount(call_count_);
   }
 
-  // Returns true if and only if this expectation is saturated.
+  // Returns true if and only if this expectation is saturated. 
   bool IsSaturated() const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsSaturatedByCallCount(call_count_);
   }
 
-  // Returns true if and only if this expectation is over-saturated.
+  // Returns true if and only if this expectation is over-saturated. 
   bool IsOverSaturated() const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return cardinality().IsOverSaturatedByCallCount(call_count_);
   }
 
-  // Returns true if and only if all pre-requisites of this expectation are
-  // satisfied.
+  // Returns true if and only if all pre-requisites of this expectation are 
+  // satisfied. 
   bool AllPrerequisitesAreSatisfied() const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
 
@@ -865,13 +865,13 @@ class GTEST_API_ ExpectationBase {
   // an EXPECT_CALL() statement finishes.
   const char* file_;          // The file that contains the expectation.
   int line_;                  // The line number of the expectation.
-  const std::string source_text_;  // The EXPECT_CALL(...) source text.
-  // True if and only if the cardinality is specified explicitly.
+  const std::string source_text_;  // The EXPECT_CALL(...) source text. 
+  // True if and only if the cardinality is specified explicitly. 
   bool cardinality_specified_;
   Cardinality cardinality_;            // The cardinality of the expectation.
   // The immediate pre-requisites (i.e. expectations that must be
   // satisfied before this expectation can be matched) of this
-  // expectation.  We use std::shared_ptr in the set because we want an
+  // expectation.  We use std::shared_ptr in the set because we want an 
   // Expectation object to be co-owned by its FunctionMocker and its
   // successors.  This allows multiple mock objects to be deleted at
   // different times.
@@ -880,7 +880,7 @@ class GTEST_API_ ExpectationBase {
   // This group of fields are the current state of the expectation,
   // and can change as the mock function is called.
   int call_count_;  // How many times this expectation has been invoked.
-  bool retired_;    // True if and only if this expectation has retired.
+  bool retired_;    // True if and only if this expectation has retired. 
   UntypedActions untyped_actions_;
   bool extra_matcher_specified_;
   bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
@@ -898,19 +898,19 @@ class TypedExpectation : public ExpectationBase {
   typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
   typedef typename Function<F>::Result Result;
 
-  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
-                   const std::string& a_source_text,
+  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line, 
+                   const std::string& a_source_text, 
                    const ArgumentMatcherTuple& m)
       : ExpectationBase(a_file, a_line, a_source_text),
         owner_(owner),
         matchers_(m),
         // By default, extra_matcher_ should match anything.  However,
-        // we cannot initialize it with _ as that causes ambiguity between
-        // Matcher's copy and move constructor for some argument types.
+        // we cannot initialize it with _ as that causes ambiguity between 
+        // Matcher's copy and move constructor for some argument types. 
         extra_matcher_(A<const ArgumentTuple&>()),
         repeated_action_(DoDefault()) {}
 
-  ~TypedExpectation() override {
+  ~TypedExpectation() override { 
     // Check the validity of the action count if it hasn't been done
     // yet (for example, if the expectation was never used).
     CheckActionCountIfNotDone();
@@ -1076,7 +1076,7 @@ class TypedExpectation : public ExpectationBase {
 
   // If this mock method has an extra matcher (i.e. .With(matcher)),
   // describes it to the ostream.
-  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
+  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override { 
     if (extra_matcher_specified_) {
       *os << "    Expected args: ";
       extra_matcher_.DescribeTo(os);
@@ -1086,25 +1086,25 @@ class TypedExpectation : public ExpectationBase {
 
  private:
   template <typename Function>
-  friend class FunctionMocker;
+  friend class FunctionMocker; 
 
   // Returns an Expectation object that references and co-owns this
   // expectation.
-  Expectation GetHandle() override { return owner_->GetHandleOf(this); }
+  Expectation GetHandle() override { return owner_->GetHandleOf(this); } 
 
   // The following methods will be called only after the EXPECT_CALL()
   // statement finishes and when the current thread holds
   // g_gmock_mutex.
 
-  // Returns true if and only if this expectation matches the given arguments.
+  // Returns true if and only if this expectation matches the given arguments. 
   bool Matches(const ArgumentTuple& args) const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
     return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
   }
 
-  // Returns true if and only if this expectation should handle the given
-  // arguments.
+  // Returns true if and only if this expectation should handle the given 
+  // arguments. 
   bool ShouldHandleArguments(const ArgumentTuple& args) const
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
@@ -1164,9 +1164,9 @@ class TypedExpectation : public ExpectationBase {
   }
 
   // Returns the action that should be taken for the current invocation.
-  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
-                                    const ArgumentTuple& args) const
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker, 
+                                    const ArgumentTuple& args) const 
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
     g_gmock_mutex.AssertHeld();
     const int count = call_count();
     Assert(count >= 1, __FILE__, __LINE__,
@@ -1188,10 +1188,10 @@ class TypedExpectation : public ExpectationBase {
       Log(kWarning, ss.str(), 1);
     }
 
-    return count <= action_count
-               ? *static_cast<const Action<F>*>(
-                     untyped_actions_[static_cast<size_t>(count - 1)])
-               : repeated_action();
+    return count <= action_count 
+               ? *static_cast<const Action<F>*>( 
+                     untyped_actions_[static_cast<size_t>(count - 1)]) 
+               : repeated_action(); 
   }
 
   // Given the arguments of a mock function call, if the call will
@@ -1201,11 +1201,11 @@ class TypedExpectation : public ExpectationBase {
   // Mock does it to 'why'.  This method is not const as it calls
   // IncrementCallCount().  A return value of NULL means the default
   // action.
-  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
-                                         const ArgumentTuple& args,
-                                         ::std::ostream* what,
-                                         ::std::ostream* why)
-      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker, 
+                                         const ArgumentTuple& args, 
+                                         ::std::ostream* what, 
+                                         ::std::ostream* why) 
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) { 
     g_gmock_mutex.AssertHeld();
     if (IsSaturated()) {
       // We have an excessive call.
@@ -1214,7 +1214,7 @@ class TypedExpectation : public ExpectationBase {
       mocker->DescribeDefaultActionTo(args, what);
       DescribeCallCountTo(why);
 
-      return nullptr;
+      return nullptr; 
     }
 
     IncrementCallCount();
@@ -1231,7 +1231,7 @@ class TypedExpectation : public ExpectationBase {
 
   // All the fields below won't change once the EXPECT_CALL()
   // statement finishes.
-  FunctionMocker<F>* const owner_;
+  FunctionMocker<F>* const owner_; 
   ArgumentMatcherTuple matchers_;
   Matcher<const ArgumentTuple&> extra_matcher_;
   Action<F> repeated_action_;
@@ -1252,7 +1252,7 @@ class TypedExpectation : public ExpectationBase {
 // Logs a message including file and line number information.
 GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
                                 const char* file, int line,
-                                const std::string& message);
+                                const std::string& message); 
 
 template <typename F>
 class MockSpec {
@@ -1263,16 +1263,16 @@ class MockSpec {
 
   // Constructs a MockSpec object, given the function mocker object
   // that the spec is associated with.
-  MockSpec(internal::FunctionMocker<F>* function_mocker,
-           const ArgumentMatcherTuple& matchers)
-      : function_mocker_(function_mocker), matchers_(matchers) {}
+  MockSpec(internal::FunctionMocker<F>* function_mocker, 
+           const ArgumentMatcherTuple& matchers) 
+      : function_mocker_(function_mocker), matchers_(matchers) {} 
 
   // Adds a new default action spec to the function mocker and returns
   // the newly created spec.
   internal::OnCallSpec<F>& InternalDefaultActionSetAt(
       const char* file, int line, const char* obj, const char* call) {
     LogWithLocation(internal::kInfo, file, line,
-                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
+                    std::string("ON_CALL(") + obj + ", " + call + ") invoked"); 
     return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
   }
 
@@ -1280,26 +1280,26 @@ class MockSpec {
   // the newly created spec.
   internal::TypedExpectation<F>& InternalExpectedAt(
       const char* file, int line, const char* obj, const char* call) {
-    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
-                                  call + ")");
+    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " + 
+                                  call + ")"); 
     LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
     return function_mocker_->AddNewExpectation(
         file, line, source_text, matchers_);
   }
 
-  // This operator overload is used to swallow the superfluous parameter list
-  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
-  // explanation.
-  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
-    return *this;
-  }
-
+  // This operator overload is used to swallow the superfluous parameter list 
+  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more 
+  // explanation. 
+  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) { 
+    return *this; 
+  } 
+ 
  private:
   template <typename Function>
   friend class internal::FunctionMocker;
 
   // The function mocker that owns this spec.
-  internal::FunctionMocker<F>* const function_mocker_;
+  internal::FunctionMocker<F>* const function_mocker_; 
   // The argument matchers specified in the spec.
   ArgumentMatcherTuple matchers_;
 };  // class MockSpec
@@ -1318,18 +1318,18 @@ class ReferenceOrValueWrapper {
  public:
   // Constructs a wrapper from the given value/reference.
   explicit ReferenceOrValueWrapper(T value)
-      : value_(std::move(value)) {
+      : value_(std::move(value)) { 
   }
 
   // Unwraps and returns the underlying value/reference, exactly as
   // originally passed. The behavior of calling this more than once on
   // the same object is unspecified.
-  T Unwrap() { return std::move(value_); }
+  T Unwrap() { return std::move(value_); } 
 
   // Provides nondestructive access to the underlying value/reference.
   // Always returns a const reference (more precisely,
-  // const std::add_lvalue_reference<T>::type). The behavior of calling this
-  // after calling Unwrap on the same object is unspecified.
+  // const std::add_lvalue_reference<T>::type). The behavior of calling this 
+  // after calling Unwrap on the same object is unspecified. 
   const T& Peek() const {
     return value_;
   }
@@ -1382,7 +1382,7 @@ class ActionResultHolder : public UntypedActionResultHolderBase {
   }
 
   // Prints the held value as an action's result to os.
-  void PrintAsActionResult(::std::ostream* os) const override {
+  void PrintAsActionResult(::std::ostream* os) const override { 
     *os << "\n          Returns: ";
     // T may be a reference type, so we don't use UniversalPrint().
     UniversalPrinter<T>::Print(result_.Peek(), os);
@@ -1392,27 +1392,27 @@ class ActionResultHolder : public UntypedActionResultHolderBase {
   // result in a new-ed ActionResultHolder.
   template <typename F>
   static ActionResultHolder* PerformDefaultAction(
-      const FunctionMocker<F>* func_mocker,
-      typename Function<F>::ArgumentTuple&& args,
-      const std::string& call_description) {
-    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
-        std::move(args), call_description)));
+      const FunctionMocker<F>* func_mocker, 
+      typename Function<F>::ArgumentTuple&& args, 
+      const std::string& call_description) { 
+    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction( 
+        std::move(args), call_description))); 
   }
 
   // Performs the given action and returns the result in a new-ed
   // ActionResultHolder.
   template <typename F>
-  static ActionResultHolder* PerformAction(
-      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
-    return new ActionResultHolder(
-        Wrapper(action.Perform(std::move(args))));
+  static ActionResultHolder* PerformAction( 
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) { 
+    return new ActionResultHolder( 
+        Wrapper(action.Perform(std::move(args)))); 
   }
 
  private:
   typedef ReferenceOrValueWrapper<T> Wrapper;
 
   explicit ActionResultHolder(Wrapper result)
-      : result_(std::move(result)) {
+      : result_(std::move(result)) { 
   }
 
   Wrapper result_;
@@ -1426,16 +1426,16 @@ class ActionResultHolder<void> : public UntypedActionResultHolderBase {
  public:
   void Unwrap() { }
 
-  void PrintAsActionResult(::std::ostream* /* os */) const override {}
+  void PrintAsActionResult(::std::ostream* /* os */) const override {} 
 
   // Performs the given mock function's default action and returns ownership
   // of an empty ActionResultHolder*.
   template <typename F>
   static ActionResultHolder* PerformDefaultAction(
-      const FunctionMocker<F>* func_mocker,
-      typename Function<F>::ArgumentTuple&& args,
-      const std::string& call_description) {
-    func_mocker->PerformDefaultAction(std::move(args), call_description);
+      const FunctionMocker<F>* func_mocker, 
+      typename Function<F>::ArgumentTuple&& args, 
+      const std::string& call_description) { 
+    func_mocker->PerformDefaultAction(std::move(args), call_description); 
     return new ActionResultHolder;
   }
 
@@ -1443,8 +1443,8 @@ class ActionResultHolder<void> : public UntypedActionResultHolderBase {
   // ActionResultHolder*.
   template <typename F>
   static ActionResultHolder* PerformAction(
-      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
-    action.Perform(std::move(args));
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) { 
+    action.Perform(std::move(args)); 
     return new ActionResultHolder;
   }
 
@@ -1454,38 +1454,38 @@ class ActionResultHolder<void> : public UntypedActionResultHolderBase {
 };
 
 template <typename F>
-class FunctionMocker;
-
-template <typename R, typename... Args>
-class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
-  using F = R(Args...);
-
+class FunctionMocker; 
+ 
+template <typename R, typename... Args> 
+class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase { 
+  using F = R(Args...); 
+ 
  public:
-  using Result = R;
-  using ArgumentTuple = std::tuple<Args...>;
-  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
-
-  FunctionMocker() {}
-
-  // There is no generally useful and implementable semantics of
-  // copying a mock object, so copying a mock is usually a user error.
-  // Thus we disallow copying function mockers.  If the user really
-  // wants to copy a mock object, they should implement their own copy
-  // operation, for example:
-  //
-  //   class MockFoo : public Foo {
-  //    public:
-  //     // Defines a copy constructor explicitly.
-  //     MockFoo(const MockFoo& src) {}
-  //     ...
-  //   };
-  FunctionMocker(const FunctionMocker&) = delete;
-  FunctionMocker& operator=(const FunctionMocker&) = delete;
-
+  using Result = R; 
+  using ArgumentTuple = std::tuple<Args...>; 
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; 
+
+  FunctionMocker() {} 
+
+  // There is no generally useful and implementable semantics of 
+  // copying a mock object, so copying a mock is usually a user error. 
+  // Thus we disallow copying function mockers.  If the user really 
+  // wants to copy a mock object, they should implement their own copy 
+  // operation, for example: 
+  // 
+  //   class MockFoo : public Foo { 
+  //    public: 
+  //     // Defines a copy constructor explicitly. 
+  //     MockFoo(const MockFoo& src) {} 
+  //     ... 
+  //   }; 
+  FunctionMocker(const FunctionMocker&) = delete; 
+  FunctionMocker& operator=(const FunctionMocker&) = delete; 
+ 
   // The destructor verifies that all expectations on this mock
   // function have been satisfied.  If not, it will report Google Test
   // non-fatal failures for the violations.
-  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
     MutexLock l(&g_gmock_mutex);
     VerifyAndClearExpectationsLocked();
     Mock::UnregisterLocked(this);
@@ -1505,7 +1505,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
         return spec;
     }
 
-    return nullptr;
+    return nullptr; 
   }
 
   // Performs the default action of this mock function on the given
@@ -1515,15 +1515,15 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // mutable state of this object, and thus can be called concurrently
   // without locking.
   // L = *
-  Result PerformDefaultAction(ArgumentTuple&& args,
-                              const std::string& call_description) const {
+  Result PerformDefaultAction(ArgumentTuple&& args, 
+                              const std::string& call_description) const { 
     const OnCallSpec<F>* const spec =
         this->FindOnCallSpec(args);
-    if (spec != nullptr) {
-      return spec->GetAction().Perform(std::move(args));
+    if (spec != nullptr) { 
+      return spec->GetAction().Perform(std::move(args)); 
     }
-    const std::string message =
-        call_description +
+    const std::string message = 
+        call_description + 
         "\n    The mock function has no default action "
         "set, and its return type has no default value set.";
 #if GTEST_HAS_EXCEPTIONS
@@ -1541,30 +1541,30 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // the error message to describe the call in the case the default
   // action fails.  The caller is responsible for deleting the result.
   // L = *
-  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
-      void* untyped_args,  // must point to an ArgumentTuple
-      const std::string& call_description) const override {
-    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformDefaultAction(this, std::move(*args),
-                                              call_description);
+  UntypedActionResultHolderBase* UntypedPerformDefaultAction( 
+      void* untyped_args,  // must point to an ArgumentTuple 
+      const std::string& call_description) const override { 
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args); 
+    return ResultHolder::PerformDefaultAction(this, std::move(*args), 
+                                              call_description); 
   }
 
   // Performs the given action with the given arguments and returns
   // the action's result.  The caller is responsible for deleting the
   // result.
   // L = *
-  UntypedActionResultHolderBase* UntypedPerformAction(
-      const void* untyped_action, void* untyped_args) const override {
+  UntypedActionResultHolderBase* UntypedPerformAction( 
+      const void* untyped_action, void* untyped_args) const override { 
     // Make a copy of the action before performing it, in case the
     // action deletes the mock object (and thus deletes itself).
     const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
-    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
-    return ResultHolder::PerformAction(action, std::move(*args));
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args); 
+    return ResultHolder::PerformAction(action, std::move(*args)); 
   }
 
   // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
   // clears the ON_CALL()s set on this mock function.
-  void ClearDefaultActionsLocked() override
+  void ClearDefaultActionsLocked() override 
       GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
 
@@ -1590,20 +1590,20 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
     g_gmock_mutex.Lock();
   }
 
-  // Returns the result of invoking this mock function with the given
-  // arguments.  This function can be safely called from multiple
-  // threads concurrently.
-  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    ArgumentTuple tuple(std::forward<Args>(args)...);
-    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
-        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
-    return holder->Unwrap();
-  }
-
-  MockSpec<F> With(Matcher<Args>... m) {
-    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
-  }
-
+  // Returns the result of invoking this mock function with the given 
+  // arguments.  This function can be safely called from multiple 
+  // threads concurrently. 
+  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
+    ArgumentTuple tuple(std::forward<Args>(args)...); 
+    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>( 
+        this->UntypedInvokeWith(static_cast<void*>(&tuple)))); 
+    return holder->Unwrap(); 
+  } 
+ 
+  MockSpec<F> With(Matcher<Args>... m) { 
+    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...)); 
+  } 
+ 
  protected:
   template <typename Function>
   friend class MockSpec;
@@ -1622,21 +1622,21 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   }
 
   // Adds and returns an expectation spec for this mock function.
-  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
-                                         const std::string& source_text,
-                                         const ArgumentMatcherTuple& m)
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  TypedExpectation<F>& AddNewExpectation(const char* file, int line, 
+                                         const std::string& source_text, 
+                                         const ArgumentMatcherTuple& m) 
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
     Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
     TypedExpectation<F>* const expectation =
         new TypedExpectation<F>(this, file, line, source_text, m);
-    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
-    // See the definition of untyped_expectations_ for why access to
-    // it is unprotected here.
+    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation); 
+    // See the definition of untyped_expectations_ for why access to 
+    // it is unprotected here. 
     untyped_expectations_.push_back(untyped_expectation);
 
     // Adds this expectation into the implicit sequence if there is one.
     Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
-    if (implicit_sequence != nullptr) {
+    if (implicit_sequence != nullptr) { 
       implicit_sequence->AddExpectation(Expectation(untyped_expectation));
     }
 
@@ -1655,9 +1655,9 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
                                ::std::ostream* os) const {
     const OnCallSpec<F>* const spec = FindOnCallSpec(args);
 
-    if (spec == nullptr) {
-      *os << (std::is_void<Result>::value ? "returning directly.\n"
-                                          : "returning default value.\n");
+    if (spec == nullptr) { 
+      *os << (std::is_void<Result>::value ? "returning directly.\n" 
+                                          : "returning default value.\n"); 
     } else {
       *os << "taking default action specified at:\n"
           << FormatFileLocation(spec->file(), spec->line()) << "\n";
@@ -1667,9 +1667,9 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // Writes a message that the call is uninteresting (i.e. neither
   // explicitly expected nor explicitly unexpected) to the given
   // ostream.
-  void UntypedDescribeUninterestingCall(const void* untyped_args,
-                                        ::std::ostream* os) const override
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  void UntypedDescribeUninterestingCall(const void* untyped_args, 
+                                        ::std::ostream* os) const override 
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
     const ArgumentTuple& args =
         *static_cast<const ArgumentTuple*>(untyped_args);
     *os << "Uninteresting mock function call - ";
@@ -1694,17 +1694,17 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
   // section.  The reason is that we have no control on what the
   // action does (it can invoke an arbitrary user function or even a
   // mock function) and excessive locking could cause a dead lock.
-  const ExpectationBase* UntypedFindMatchingExpectation(
-      const void* untyped_args, const void** untyped_action, bool* is_excessive,
-      ::std::ostream* what, ::std::ostream* why) override
-      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const ExpectationBase* UntypedFindMatchingExpectation( 
+      const void* untyped_args, const void** untyped_action, bool* is_excessive, 
+      ::std::ostream* what, ::std::ostream* why) override 
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
     const ArgumentTuple& args =
         *static_cast<const ArgumentTuple*>(untyped_args);
     MutexLock l(&g_gmock_mutex);
     TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
-    if (exp == nullptr) {  // A match wasn't found.
+    if (exp == nullptr) {  // A match wasn't found. 
       this->FormatUnexpectedCallMessageLocked(args, what, why);
-      return nullptr;
+      return nullptr; 
     }
 
     // This line must be done before calling GetActionForArguments(),
@@ -1712,15 +1712,15 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
     // its saturation status.
     *is_excessive = exp->IsSaturated();
     const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
-    if (action != nullptr && action->IsDoDefault())
-      action = nullptr;  // Normalize "do default" to NULL.
+    if (action != nullptr && action->IsDoDefault()) 
+      action = nullptr;  // Normalize "do default" to NULL. 
     *untyped_action = action;
     return exp;
   }
 
   // Prints the given function arguments to the ostream.
-  void UntypedPrintArgs(const void* untyped_args,
-                        ::std::ostream* os) const override {
+  void UntypedPrintArgs(const void* untyped_args, 
+                        ::std::ostream* os) const override { 
     const ArgumentTuple& args =
         *static_cast<const ArgumentTuple*>(untyped_args);
     UniversalPrint(args, os);
@@ -1732,8 +1732,8 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
       const ArgumentTuple& args) const
           GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
-    // See the definition of untyped_expectations_ for why access to
-    // it is unprotected here.
+    // See the definition of untyped_expectations_ for why access to 
+    // it is unprotected here. 
     for (typename UntypedExpectations::const_reverse_iterator it =
              untyped_expectations_.rbegin();
          it != untyped_expectations_.rend(); ++it) {
@@ -1743,7 +1743,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
         return exp;
       }
     }
-    return nullptr;
+    return nullptr; 
   }
 
   // Returns a message that the arguments don't match any expectation.
@@ -1765,12 +1765,12 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
       ::std::ostream* why) const
           GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
     g_gmock_mutex.AssertHeld();
-    const size_t count = untyped_expectations_.size();
+    const size_t count = untyped_expectations_.size(); 
     *why << "Google Mock tried the following " << count << " "
          << (count == 1 ? "expectation, but it didn't match" :
              "expectations, but none matched")
          << ":\n";
-    for (size_t i = 0; i < count; i++) {
+    for (size_t i = 0; i < count; i++) { 
       TypedExpectation<F>* const expectation =
           static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
       *why << "\n";
@@ -1783,152 +1783,152 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
       expectation->DescribeCallCountTo(why);
     }
   }
-};  // class FunctionMocker
-
-// Reports an uninteresting call (whose description is in msg) in the
-// manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
-
-}  // namespace internal
-
-namespace internal {
-
-template <typename F>
-class MockFunction;
-
-template <typename R, typename... Args>
-class MockFunction<R(Args...)> {
- public:
-  MockFunction(const MockFunction&) = delete;
-  MockFunction& operator=(const MockFunction&) = delete;
-
-  std::function<R(Args...)> AsStdFunction() {
-    return [this](Args... args) -> R {
-      return this->Call(std::forward<Args>(args)...);
-    };
-  }
-
-  // Implementation detail: the expansion of the MOCK_METHOD macro.
-  R Call(Args... args) {
-    mock_.SetOwnerAndName(this, "Call");
-    return mock_.Invoke(std::forward<Args>(args)...);
-  }
-
-  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
-    mock_.RegisterOwner(this);
-    return mock_.With(std::move(m)...);
-  }
-
-  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
-    return this->gmock_Call(::testing::A<Args>()...);
-  }
-
- protected:
-  MockFunction() = default;
-  ~MockFunction() = default;
-
- private:
-  FunctionMocker<R(Args...)> mock_;
-};
-
-/*
-The SignatureOf<F> struct is a meta-function returning function signature
-corresponding to the provided F argument.
-
-It makes use of MockFunction easier by allowing it to accept more F arguments
-than just function signatures.
-
-Specializations provided here cover a signature type itself and any template
-that can be parameterized with a signature, including std::function and
-boost::function.
-*/
-
-template <typename F, typename = void>
-struct SignatureOf;
-
-template <typename R, typename... Args>
-struct SignatureOf<R(Args...)> {
-  using type = R(Args...);
-};
-
-template <template <typename> class C, typename F>
-struct SignatureOf<C<F>,
-                   typename std::enable_if<std::is_function<F>::value>::type>
-    : SignatureOf<F> {};
-
-template <typename F>
-using SignatureOfT = typename SignatureOf<F>::type;
-
-}  // namespace internal
-
-// A MockFunction<F> type has one mock method whose type is
-// internal::SignatureOfT<F>.  It is useful when you just want your
-// test code to emit some messages and have Google Mock verify the
-// right messages are sent (and perhaps at the right times).  For
-// example, if you are exercising code:
-//
-//   Foo(1);
-//   Foo(2);
-//   Foo(3);
-//
-// and want to verify that Foo(1) and Foo(3) both invoke
-// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
-//
-// TEST(FooTest, InvokesBarCorrectly) {
-//   MyMock mock;
-//   MockFunction<void(string check_point_name)> check;
-//   {
-//     InSequence s;
-//
-//     EXPECT_CALL(mock, Bar("a"));
-//     EXPECT_CALL(check, Call("1"));
-//     EXPECT_CALL(check, Call("2"));
-//     EXPECT_CALL(mock, Bar("a"));
-//   }
-//   Foo(1);
-//   check.Call("1");
-//   Foo(2);
-//   check.Call("2");
-//   Foo(3);
-// }
-//
-// The expectation spec says that the first Bar("a") must happen
-// before check point "1", the second Bar("a") must happen after check
-// point "2", and nothing should happen between the two check
-// points. The explicit check points make it easy to tell which
-// Bar("a") is called by which call to Foo().
-//
-// MockFunction<F> can also be used to exercise code that accepts
-// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
-// AsStdFunction() method to create std::function proxy forwarding to
-// original object's Call. Example:
-//
-// TEST(FooTest, RunsCallbackWithBarArgument) {
-//   MockFunction<int(string)> callback;
-//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
-//   Foo(callback.AsStdFunction());
-// }
-//
-// The internal::SignatureOfT<F> indirection allows to use other types
-// than just function signature type. This is typically useful when
-// providing a mock for a predefined std::function type. Example:
-//
-// using FilterPredicate = std::function<bool(string)>;
-// void MyFilterAlgorithm(FilterPredicate predicate);
-//
-// TEST(FooTest, FilterPredicateAlwaysAccepts) {
-//   MockFunction<FilterPredicate> predicateMock;
-//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
-//   MyFilterAlgorithm(predicateMock.AsStdFunction());
-// }
-template <typename F>
-class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
-  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
-
- public:
-  using Base::Base;
-};
-
+};  // class FunctionMocker 
+
+// Reports an uninteresting call (whose description is in msg) in the 
+// manner specified by 'reaction'. 
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg); 
+
+}  // namespace internal 
+
+namespace internal { 
+ 
+template <typename F> 
+class MockFunction; 
+ 
+template <typename R, typename... Args> 
+class MockFunction<R(Args...)> { 
+ public: 
+  MockFunction(const MockFunction&) = delete; 
+  MockFunction& operator=(const MockFunction&) = delete; 
+ 
+  std::function<R(Args...)> AsStdFunction() { 
+    return [this](Args... args) -> R { 
+      return this->Call(std::forward<Args>(args)...); 
+    }; 
+  } 
+ 
+  // Implementation detail: the expansion of the MOCK_METHOD macro. 
+  R Call(Args... args) { 
+    mock_.SetOwnerAndName(this, "Call"); 
+    return mock_.Invoke(std::forward<Args>(args)...); 
+  } 
+ 
+  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) { 
+    mock_.RegisterOwner(this); 
+    return mock_.With(std::move(m)...); 
+  } 
+ 
+  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) { 
+    return this->gmock_Call(::testing::A<Args>()...); 
+  } 
+ 
+ protected: 
+  MockFunction() = default; 
+  ~MockFunction() = default; 
+ 
+ private: 
+  FunctionMocker<R(Args...)> mock_; 
+}; 
+ 
+/* 
+The SignatureOf<F> struct is a meta-function returning function signature 
+corresponding to the provided F argument. 
+ 
+It makes use of MockFunction easier by allowing it to accept more F arguments 
+than just function signatures. 
+ 
+Specializations provided here cover a signature type itself and any template 
+that can be parameterized with a signature, including std::function and 
+boost::function. 
+*/ 
+ 
+template <typename F, typename = void> 
+struct SignatureOf; 
+ 
+template <typename R, typename... Args> 
+struct SignatureOf<R(Args...)> { 
+  using type = R(Args...); 
+}; 
+ 
+template <template <typename> class C, typename F> 
+struct SignatureOf<C<F>, 
+                   typename std::enable_if<std::is_function<F>::value>::type> 
+    : SignatureOf<F> {}; 
+ 
+template <typename F> 
+using SignatureOfT = typename SignatureOf<F>::type; 
+ 
+}  // namespace internal 
+ 
+// A MockFunction<F> type has one mock method whose type is 
+// internal::SignatureOfT<F>.  It is useful when you just want your 
+// test code to emit some messages and have Google Mock verify the 
+// right messages are sent (and perhaps at the right times).  For 
+// example, if you are exercising code: 
+// 
+//   Foo(1); 
+//   Foo(2); 
+//   Foo(3); 
+// 
+// and want to verify that Foo(1) and Foo(3) both invoke 
+// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write: 
+// 
+// TEST(FooTest, InvokesBarCorrectly) { 
+//   MyMock mock; 
+//   MockFunction<void(string check_point_name)> check; 
+//   { 
+//     InSequence s; 
+// 
+//     EXPECT_CALL(mock, Bar("a")); 
+//     EXPECT_CALL(check, Call("1")); 
+//     EXPECT_CALL(check, Call("2")); 
+//     EXPECT_CALL(mock, Bar("a")); 
+//   } 
+//   Foo(1); 
+//   check.Call("1"); 
+//   Foo(2); 
+//   check.Call("2"); 
+//   Foo(3); 
+// } 
+// 
+// The expectation spec says that the first Bar("a") must happen 
+// before check point "1", the second Bar("a") must happen after check 
+// point "2", and nothing should happen between the two check 
+// points. The explicit check points make it easy to tell which 
+// Bar("a") is called by which call to Foo(). 
+// 
+// MockFunction<F> can also be used to exercise code that accepts 
+// std::function<internal::SignatureOfT<F>> callbacks. To do so, use 
+// AsStdFunction() method to create std::function proxy forwarding to 
+// original object's Call. Example: 
+// 
+// TEST(FooTest, RunsCallbackWithBarArgument) { 
+//   MockFunction<int(string)> callback; 
+//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1)); 
+//   Foo(callback.AsStdFunction()); 
+// } 
+// 
+// The internal::SignatureOfT<F> indirection allows to use other types 
+// than just function signature type. This is typically useful when 
+// providing a mock for a predefined std::function type. Example: 
+// 
+// using FilterPredicate = std::function<bool(string)>; 
+// void MyFilterAlgorithm(FilterPredicate predicate); 
+// 
+// TEST(FooTest, FilterPredicateAlwaysAccepts) { 
+//   MockFunction<FilterPredicate> predicateMock; 
+//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true)); 
+//   MyFilterAlgorithm(predicateMock.AsStdFunction()); 
+// } 
+template <typename F> 
+class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> { 
+  using Base = internal::MockFunction<internal::SignatureOfT<F>>; 
+
+ public: 
+  using Base::Base; 
+}; 
+ 
 // The style guide prohibits "using" statements in a namespace scope
 // inside a header file.  However, the MockSpec class template is
 // meant to be defined in the ::testing namespace.  The following line
@@ -1960,79 +1960,79 @@ inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
 
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
-// required to avoid compile errors when the name of the method used in call is
-// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
-// tests in internal/gmock-spec-builders_test.cc for more details.
-//
-// This macro supports statements both with and without parameter matchers. If
-// the parameter list is omitted, gMock will accept any parameters, which allows
-// tests to be written that don't need to encode the number of method
-// parameter. This technique may only be used for non-overloaded methods.
-//
-//   // These are the same:
-//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
-//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
-//
-//   // As are these:
-//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
-//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
-//
-//   // Can also specify args if you want, of course:
-//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
-//
-//   // Overloads work as long as you specify parameters:
-//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
-//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
-//
-//   // Oops! Which overload did you want?
-//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
-//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
-//
-// How this works: The mock class uses two overloads of the gmock_Method
-// expectation setter method plus an operator() overload on the MockSpec object.
-// In the matcher list form, the macro expands to:
-//
-//   // This statement:
-//   ON_CALL(mock, TwoArgsMethod(_, 45))...
-//
-//   // ...expands to:
-//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
-//   |-------------v---------------||------------v-------------|
-//       invokes first overload        swallowed by operator()
-//
-//   // ...which is essentially:
-//   mock.gmock_TwoArgsMethod(_, 45)...
-//
-// Whereas the form without a matcher list:
-//
-//   // This statement:
-//   ON_CALL(mock, TwoArgsMethod)...
-//
-//   // ...expands to:
-//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
-//   |-----------------------v--------------------------|
-//                 invokes second overload
-//
-//   // ...which is essentially:
-//   mock.gmock_TwoArgsMethod(_, _)...
-//
-// The WithoutMatchers() argument is used to disambiguate overloads and to
-// block the caller from accidentally invoking the second overload directly. The
-// second argument is an internal type derived from the method signature. The
-// failure to disambiguate two overloads of this method in the ON_CALL statement
-// is how we block callers from setting expectations on overloaded methods.
-#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
-  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
-                             nullptr)                                   \
-      .Setter(__FILE__, __LINE__, #mock_expr, #call)
-
-#define ON_CALL(obj, call) \
-  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
-
-#define EXPECT_CALL(obj, call) \
-  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+
+// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is 
+// required to avoid compile errors when the name of the method used in call is 
+// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro 
+// tests in internal/gmock-spec-builders_test.cc for more details. 
+// 
+// This macro supports statements both with and without parameter matchers. If 
+// the parameter list is omitted, gMock will accept any parameters, which allows 
+// tests to be written that don't need to encode the number of method 
+// parameter. This technique may only be used for non-overloaded methods. 
+// 
+//   // These are the same: 
+//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...); 
+//   ON_CALL(mock, NoArgsMethod).WillByDefault(...); 
+// 
+//   // As are these: 
+//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...); 
+//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...); 
+// 
+//   // Can also specify args if you want, of course: 
+//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...); 
+// 
+//   // Overloads work as long as you specify parameters: 
+//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...); 
+//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...); 
+// 
+//   // Oops! Which overload did you want? 
+//   ON_CALL(mock, OverloadedMethod).WillByDefault(...); 
+//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous 
+// 
+// How this works: The mock class uses two overloads of the gmock_Method 
+// expectation setter method plus an operator() overload on the MockSpec object. 
+// In the matcher list form, the macro expands to: 
+// 
+//   // This statement: 
+//   ON_CALL(mock, TwoArgsMethod(_, 45))... 
+// 
+//   // ...expands to: 
+//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)... 
+//   |-------------v---------------||------------v-------------| 
+//       invokes first overload        swallowed by operator() 
+// 
+//   // ...which is essentially: 
+//   mock.gmock_TwoArgsMethod(_, 45)... 
+// 
+// Whereas the form without a matcher list: 
+// 
+//   // This statement: 
+//   ON_CALL(mock, TwoArgsMethod)... 
+// 
+//   // ...expands to: 
+//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)... 
+//   |-----------------------v--------------------------| 
+//                 invokes second overload 
+// 
+//   // ...which is essentially: 
+//   mock.gmock_TwoArgsMethod(_, _)... 
+// 
+// The WithoutMatchers() argument is used to disambiguate overloads and to 
+// block the caller from accidentally invoking the second overload directly. The 
+// second argument is an internal type derived from the method signature. The 
+// failure to disambiguate two overloads of this method in the ON_CALL statement 
+// is how we block callers from setting expectations on overloaded methods. 
+#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \ 
+  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \ 
+                             nullptr)                                   \ 
+      .Setter(__FILE__, __LINE__, #mock_expr, #call) 
+
+#define ON_CALL(obj, call) \ 
+  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call) 
+ 
+#define EXPECT_CALL(obj, call) \ 
+  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call) 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/gmock.h b/contrib/restricted/googletest/googlemock/include/gmock/gmock.h
index 12469bc466..148f508c30 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/gmock.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/gmock.h
@@ -27,26 +27,26 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This is the main header file a user should include.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ 
 
 // This file implements the following syntax:
 //
-//   ON_CALL(mock_object, Method(...))
+//   ON_CALL(mock_object, Method(...)) 
 //     .With(...) ?
 //     .WillByDefault(...);
 //
 // where With() is optional and WillByDefault() must appear exactly
 // once.
 //
-//   EXPECT_CALL(mock_object, Method(...))
+//   EXPECT_CALL(mock_object, Method(...)) 
 //     .With(...) ?
 //     .Times(...) ?
 //     .InSequence(...) *
@@ -58,11 +58,11 @@
 
 #include "gmock/gmock-actions.h"
 #include "gmock/gmock-cardinalities.h"
-#include "gmock/gmock-function-mocker.h"
+#include "gmock/gmock-function-mocker.h" 
 #include "gmock/gmock-matchers.h"
 #include "gmock/gmock-more-actions.h"
 #include "gmock/gmock-more-matchers.h"
-#include "gmock/gmock-nice-strict.h"
+#include "gmock/gmock-nice-strict.h" 
 #include "gmock/internal/gmock-internal-utils.h"
 
 namespace testing {
@@ -70,7 +70,7 @@ namespace testing {
 // Declares Google Mock flags that we want a user to use programmatically.
 GMOCK_DECLARE_bool_(catch_leaked_mocks);
 GMOCK_DECLARE_string_(verbose);
-GMOCK_DECLARE_int32_(default_mock_behavior);
+GMOCK_DECLARE_int32_(default_mock_behavior); 
 
 // Initializes Google Mock.  This must be called before running the
 // tests.  In particular, it parses the command line for the flags
@@ -89,10 +89,10 @@ GTEST_API_ void InitGoogleMock(int* argc, char** argv);
 // UNICODE mode.
 GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
 
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-GTEST_API_ void InitGoogleMock();
-
+// This overloaded version can be used on Arduino/embedded platforms where 
+// there is no argc/argv. 
+GTEST_API_ void InitGoogleMock(); 
+ 
 }  // namespace testing
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
index 63f899962e..d1ebfb912e 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
@@ -1,6 +1,6 @@
-// GOOGLETEST_CM0002 DO NOT DELETE
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
index 638429488e..f7d0e2d33b 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-matchers.h
@@ -27,10 +27,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// Injection point for custom user configurations. See README for details
+// Injection point for custom user configurations. See README for details 
 //
-// GOOGLETEST_CM0002 DO NOT DELETE
+// GOOGLETEST_CM0002 DO NOT DELETE 
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-port.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
index 14378692ae..932b74eedc 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/custom/gmock-port.h
@@ -27,13 +27,13 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// Injection point for custom user configurations. See README for details
+// Injection point for custom user configurations. See README for details 
 //
 // ** Custom implementation starts here **
 
-// GOOGLETEST_CM0002 DO NOT DELETE
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ 
 
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
index 317544a7da..67b56f9510 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -27,49 +27,49 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file defines some utilities useful for implementing Google
 // Mock.  They are subject to change without notice, so please DO NOT
 // USE THEM IN USER CODE.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 
 
 #include <stdio.h>
 #include <ostream>  // NOLINT
 #include <string>
-#include <type_traits>
+#include <type_traits> 
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest.h"
 
 namespace testing {
-
-template <typename>
-class Matcher;
-
+ 
+template <typename> 
+class Matcher; 
+ 
 namespace internal {
 
-// Silence MSVC C4100 (unreferenced formal parameter) and
-// C4805('==': unsafe mix of type 'const int' and type 'const bool')
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable:4100)
-# pragma warning(disable:4805)
-#endif
-
-// Joins a vector of strings as if they are fields of a tuple; returns
-// the joined string.
-GTEST_API_ std::string JoinAsTuple(const Strings& fields);
-
+// Silence MSVC C4100 (unreferenced formal parameter) and 
+// C4805('==': unsafe mix of type 'const int' and type 'const bool') 
+#ifdef _MSC_VER 
+# pragma warning(push) 
+# pragma warning(disable:4100) 
+# pragma warning(disable:4805) 
+#endif 
+ 
+// Joins a vector of strings as if they are fields of a tuple; returns 
+// the joined string. 
+GTEST_API_ std::string JoinAsTuple(const Strings& fields); 
+ 
 // Converts an identifier name to a space-separated list of lower-case
 // words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
 // treated as one word.  For example, both "FooBar123" and
 // "foo_bar_123" are converted to "foo bar 123".
-GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name); 
 
 // GetRawPointer(p) returns the raw pointer underlying p when p is a
 // smart pointer, or returns p itself when p is already a raw pointer.
@@ -86,7 +86,7 @@ inline Element* GetRawPointer(Element* p) { return p; }
 // same as unsigned short when the compiler option /Zc:wchar_t- is
 // specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
 // is a native type.
-#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED) 
 // wchar_t is a typedef.
 #else
 # define GMOCK_WCHAR_T_IS_NATIVE_ 1
@@ -122,8 +122,8 @@ GMOCK_DECLARE_KIND_(int, kInteger);
 GMOCK_DECLARE_KIND_(unsigned int, kInteger);
 GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
 GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
-GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT 
+GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT 
 
 #if GMOCK_WCHAR_T_IS_NATIVE_
 GMOCK_DECLARE_KIND_(wchar_t, kInteger);
@@ -142,7 +142,7 @@ GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
       ::testing::internal::KindOf<type>::value)
 
 // LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
-// is true if and only if arithmetic type From can be losslessly converted to
+// is true if and only if arithmetic type From can be losslessly converted to 
 // arithmetic type To.
 //
 // It's the user's responsibility to ensure that both From and To are
@@ -151,42 +151,42 @@ GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
 // From, and kToKind is the kind of To; the value is
 // implementation-defined when the above pre-condition is violated.
 template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
-using LosslessArithmeticConvertibleImpl = std::integral_constant<
-    bool,
-    // clang-format off
-      // Converting from bool is always lossless
-      (kFromKind == kBool) ? true
-      // Converting between any other type kinds will be lossy if the type
-      // kinds are not the same.
-    : (kFromKind != kToKind) ? false
-    : (kFromKind == kInteger &&
-       // Converting between integers of different widths is allowed so long
-       // as the conversion does not go from signed to unsigned.
-      (((sizeof(From) < sizeof(To)) &&
-        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
-       // Converting between integers of the same width only requires the
-       // two types to have the same signedness.
-       ((sizeof(From) == sizeof(To)) &&
-        (std::is_signed<From>::value == std::is_signed<To>::value)))
-       ) ? true
-      // Floating point conversions are lossless if and only if `To` is at least
-      // as wide as `From`.
-    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
-    : false
-    // clang-format on
-    >;
-
-// LosslessArithmeticConvertible<From, To>::value is true if and only if
-// arithmetic type From can be losslessly converted to arithmetic type To.
+using LosslessArithmeticConvertibleImpl = std::integral_constant< 
+    bool, 
+    // clang-format off 
+      // Converting from bool is always lossless 
+      (kFromKind == kBool) ? true 
+      // Converting between any other type kinds will be lossy if the type 
+      // kinds are not the same. 
+    : (kFromKind != kToKind) ? false 
+    : (kFromKind == kInteger && 
+       // Converting between integers of different widths is allowed so long 
+       // as the conversion does not go from signed to unsigned. 
+      (((sizeof(From) < sizeof(To)) && 
+        !(std::is_signed<From>::value && !std::is_signed<To>::value)) || 
+       // Converting between integers of the same width only requires the 
+       // two types to have the same signedness. 
+       ((sizeof(From) == sizeof(To)) && 
+        (std::is_signed<From>::value == std::is_signed<To>::value))) 
+       ) ? true 
+      // Floating point conversions are lossless if and only if `To` is at least 
+      // as wide as `From`. 
+    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true 
+    : false 
+    // clang-format on 
+    >; 
+
+// LosslessArithmeticConvertible<From, To>::value is true if and only if 
+// arithmetic type From can be losslessly converted to arithmetic type To. 
 //
 // It's the user's responsibility to ensure that both From and To are
 // raw (i.e. has no CV modifier, is not a pointer, and is not a
 // reference) built-in arithmetic types; the value is
 // implementation-defined when the above pre-condition is violated.
 template <typename From, typename To>
-using LosslessArithmeticConvertible =
-    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
-                                      GMOCK_KIND_OF_(To), To>;
+using LosslessArithmeticConvertible = 
+    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From, 
+                                      GMOCK_KIND_OF_(To), To>; 
 
 // This interface knows how to report a Google Mock failure (either
 // non-fatal or fatal).
@@ -201,7 +201,7 @@ class FailureReporterInterface {
 
   // Reports a failure that occurred at the given source file location.
   virtual void ReportFailure(FailureType type, const char* file, int line,
-                             const std::string& message) = 0;
+                             const std::string& message) = 0; 
 };
 
 // Returns the failure reporter used by Google Mock.
@@ -213,7 +213,7 @@ GTEST_API_ FailureReporterInterface* GetFailureReporter();
 // inline this function to prevent it from showing up in the stack
 // trace.
 inline void Assert(bool condition, const char* file, int line,
-                   const std::string& msg) {
+                   const std::string& msg) { 
   if (!condition) {
     GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
                                         file, line, msg);
@@ -226,7 +226,7 @@ inline void Assert(bool condition, const char* file, int line) {
 // Verifies that condition is true; generates a non-fatal failure if
 // condition is false.
 inline void Expect(bool condition, const char* file, int line,
-                   const std::string& msg) {
+                   const std::string& msg) { 
   if (!condition) {
     GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
                                         file, line, msg);
@@ -251,35 +251,35 @@ const char kWarningVerbosity[] = "warning";
 // No logs are printed.
 const char kErrorVerbosity[] = "error";
 
-// Returns true if and only if a log with the given severity is visible
-// according to the --gmock_verbose flag.
+// Returns true if and only if a log with the given severity is visible 
+// according to the --gmock_verbose flag. 
 GTEST_API_ bool LogIsVisible(LogSeverity severity);
 
-// Prints the given message to stdout if and only if 'severity' >= the level
+// Prints the given message to stdout if and only if 'severity' >= the level 
 // specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
 // 0, also prints the stack trace excluding the top
 // stack_frames_to_skip frames.  In opt mode, any positive
 // stack_frames_to_skip is treated as 0, since we don't know which
 // function calls will be inlined by the compiler and need to be
 // conservative.
-GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+GTEST_API_ void Log(LogSeverity severity, const std::string& message, 
                     int stack_frames_to_skip);
 
-// A marker class that is used to resolve parameterless expectations to the
-// correct overload. This must not be instantiable, to prevent client code from
-// accidentally resolving to the overload; for example:
-//
-//    ON_CALL(mock, Method({}, nullptr))...
-//
-class WithoutMatchers {
- private:
-  WithoutMatchers() {}
-  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
-};
-
-// Internal use only: access the singleton instance of WithoutMatchers.
-GTEST_API_ WithoutMatchers GetWithoutMatchers();
-
+// A marker class that is used to resolve parameterless expectations to the 
+// correct overload. This must not be instantiable, to prevent client code from 
+// accidentally resolving to the overload; for example: 
+// 
+//    ON_CALL(mock, Method({}, nullptr))... 
+// 
+class WithoutMatchers { 
+ private: 
+  WithoutMatchers() {} 
+  friend GTEST_API_ WithoutMatchers GetWithoutMatchers(); 
+}; 
+
+// Internal use only: access the singleton instance of WithoutMatchers. 
+GTEST_API_ WithoutMatchers GetWithoutMatchers(); 
+ 
 // Disable MSVC warnings for infinite recursion, since in this case the
 // the recursion is unreachable.
 #ifdef _MSC_VER
@@ -328,8 +328,8 @@ class StlContainerView {
   typedef const type& const_reference;
 
   static const_reference ConstReference(const RawContainer& container) {
-    static_assert(!std::is_const<RawContainer>::value,
-                  "RawContainer type must not be const");
+    static_assert(!std::is_const<RawContainer>::value, 
+                  "RawContainer type must not be const"); 
     return container;
   }
   static type Copy(const RawContainer& container) { return container; }
@@ -339,7 +339,7 @@ class StlContainerView {
 template <typename Element, size_t N>
 class StlContainerView<Element[N]> {
  public:
-  typedef typename std::remove_const<Element>::type RawElement;
+  typedef typename std::remove_const<Element>::type RawElement; 
   typedef internal::NativeArray<RawElement> type;
   // NativeArray<T> can represent a native array either by value or by
   // reference (selected by a constructor argument), so 'const type'
@@ -349,8 +349,8 @@ class StlContainerView<Element[N]> {
   typedef const type const_reference;
 
   static const_reference ConstReference(const Element (&array)[N]) {
-    static_assert(std::is_same<Element, RawElement>::value,
-                  "Element type must not be const");
+    static_assert(std::is_same<Element, RawElement>::value, 
+                  "Element type must not be const"); 
     return type(array, N, RelationToSourceReference());
   }
   static type Copy(const Element (&array)[N]) {
@@ -361,21 +361,21 @@ class StlContainerView<Element[N]> {
 // This specialization is used when RawContainer is a native array
 // represented as a (pointer, size) tuple.
 template <typename ElementPointer, typename Size>
-class StlContainerView< ::std::tuple<ElementPointer, Size> > {
+class StlContainerView< ::std::tuple<ElementPointer, Size> > { 
  public:
-  typedef typename std::remove_const<
-      typename std::pointer_traits<ElementPointer>::element_type>::type
-      RawElement;
+  typedef typename std::remove_const< 
+      typename std::pointer_traits<ElementPointer>::element_type>::type 
+      RawElement; 
   typedef internal::NativeArray<RawElement> type;
   typedef const type const_reference;
 
   static const_reference ConstReference(
-      const ::std::tuple<ElementPointer, Size>& array) {
-    return type(std::get<0>(array), std::get<1>(array),
-                RelationToSourceReference());
+      const ::std::tuple<ElementPointer, Size>& array) { 
+    return type(std::get<0>(array), std::get<1>(array), 
+                RelationToSourceReference()); 
   }
-  static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
-    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy());
+  static type Copy(const ::std::tuple<ElementPointer, Size>& array) { 
+    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy()); 
   }
 };
 
@@ -397,63 +397,63 @@ struct RemoveConstFromKey<std::pair<const K, V> > {
   typedef std::pair<K, V> type;
 };
 
-// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to
-// reduce code size.
-GTEST_API_ void IllegalDoDefault(const char* file, int line);
-
-template <typename F, typename Tuple, size_t... Idx>
-auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
-    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
-  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
-}
-
-// Apply the function to a tuple of arguments.
-template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& args) -> decltype(
-    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-              MakeIndexSequence<std::tuple_size<
-                  typename std::remove_reference<Tuple>::type>::value>())) {
-  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-                   MakeIndexSequence<std::tuple_size<
-                       typename std::remove_reference<Tuple>::type>::value>());
-}
-
-// Template struct Function<F>, where F must be a function type, contains
-// the following typedefs:
-//
-//   Result:               the function's return type.
-//   Arg<N>:               the type of the N-th argument, where N starts with 0.
-//   ArgumentTuple:        the tuple type consisting of all parameters of F.
-//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
-//                         parameters of F.
-//   MakeResultVoid:       the function type obtained by substituting void
-//                         for the return type of F.
-//   MakeResultIgnoredValue:
-//                         the function type obtained by substituting Something
-//                         for the return type of F.
-template <typename T>
-struct Function;
-
-template <typename R, typename... Args>
-struct Function<R(Args...)> {
-  using Result = R;
-  static constexpr size_t ArgumentCount = sizeof...(Args);
-  template <size_t I>
-  using Arg = ElemFromList<I, Args...>;
-  using ArgumentTuple = std::tuple<Args...>;
-  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
-  using MakeResultVoid = void(Args...);
-  using MakeResultIgnoredValue = IgnoredValue(Args...);
-};
-
-template <typename R, typename... Args>
-constexpr size_t Function<R(Args...)>::ArgumentCount;
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
+// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to 
+// reduce code size. 
+GTEST_API_ void IllegalDoDefault(const char* file, int line); 
+
+template <typename F, typename Tuple, size_t... Idx> 
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype( 
+    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) { 
+  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...); 
+} 
+ 
+// Apply the function to a tuple of arguments. 
+template <typename F, typename Tuple> 
+auto Apply(F&& f, Tuple&& args) -> decltype( 
+    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), 
+              MakeIndexSequence<std::tuple_size< 
+                  typename std::remove_reference<Tuple>::type>::value>())) { 
+  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), 
+                   MakeIndexSequence<std::tuple_size< 
+                       typename std::remove_reference<Tuple>::type>::value>()); 
+} 
+ 
+// Template struct Function<F>, where F must be a function type, contains 
+// the following typedefs: 
+// 
+//   Result:               the function's return type. 
+//   Arg<N>:               the type of the N-th argument, where N starts with 0. 
+//   ArgumentTuple:        the tuple type consisting of all parameters of F. 
+//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all 
+//                         parameters of F. 
+//   MakeResultVoid:       the function type obtained by substituting void 
+//                         for the return type of F. 
+//   MakeResultIgnoredValue: 
+//                         the function type obtained by substituting Something 
+//                         for the return type of F. 
+template <typename T> 
+struct Function; 
+ 
+template <typename R, typename... Args> 
+struct Function<R(Args...)> { 
+  using Result = R; 
+  static constexpr size_t ArgumentCount = sizeof...(Args); 
+  template <size_t I> 
+  using Arg = ElemFromList<I, Args...>; 
+  using ArgumentTuple = std::tuple<Args...>; 
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; 
+  using MakeResultVoid = void(Args...); 
+  using MakeResultIgnoredValue = IgnoredValue(Args...); 
+}; 
+ 
+template <typename R, typename... Args> 
+constexpr size_t Function<R(Args...)>::ArgumentCount; 
+ 
+#ifdef _MSC_VER 
+# pragma warning(pop) 
+#endif 
+ 
 }  // namespace internal
 }  // namespace testing
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-port.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-port.h
index 367a44d366..f0ff449600 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-port.h
@@ -26,7 +26,7 @@
 // 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.
-
+ 
 //
 // Low-level types and utilities for porting Google Mock to various
 // platforms.  All macros ending with _ and symbols defined in an
@@ -35,14 +35,14 @@
 // end with _ are part of Google Mock's public API and can be used by
 // code outside Google Mock.
 
-// GOOGLETEST_CM0002 DO NOT DELETE
-
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+// GOOGLETEST_CM0002 DO NOT DELETE 
+ 
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ 
 
 #include <assert.h>
 #include <stdlib.h>
-#include <cstdint>
+#include <cstdint> 
 #include <iostream>
 
 // Most of the utilities needed for porting Google Mock are also
@@ -52,14 +52,14 @@
 // portability utilities to Google Test's gtest-port.h instead of
 // here, as Google Mock depends on Google Test.  Only add a utility
 // here if it's truly specific to Google Mock.
-
+ 
 #include "gtest/internal/gtest-port.h"
 #include "gmock/internal/custom/gmock-port.h"
 
-// For MS Visual C++, check the compiler version. At least VS 2015 is
+// For MS Visual C++, check the compiler version. At least VS 2015 is 
 // required to compile Google Mock.
-#if defined(_MSC_VER) && _MSC_VER < 1900
-# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
+#if defined(_MSC_VER) && _MSC_VER < 1900 
+# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock." 
 #endif
 
 // Macro for referencing flags.  This is public as we want the user to
@@ -69,19 +69,19 @@
 #if !defined(GMOCK_DECLARE_bool_)
 
 // Macros for declaring flags.
-# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
-# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name)
-# define GMOCK_DECLARE_string_(name) \
+# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name) 
+# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name) 
+# define GMOCK_DECLARE_string_(name) \ 
     extern GTEST_API_ ::std::string GMOCK_FLAG(name)
 
 // Macros for defining flags.
-# define GMOCK_DEFINE_bool_(name, default_val, doc) \
+# define GMOCK_DEFINE_bool_(name, default_val, doc) \ 
     GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
-# define GMOCK_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val)
-# define GMOCK_DEFINE_string_(name, default_val, doc) \
+# define GMOCK_DEFINE_int32_(name, default_val, doc) \ 
+    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val) 
+# define GMOCK_DEFINE_string_(name, default_val, doc) \ 
     GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
 
 #endif  // !defined(GMOCK_DECLARE_bool_)
 
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ 
diff --git a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-pp.h b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-pp.h
index 94d61c09c8..8b32dc7199 100644
--- a/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-pp.h
+++ b/contrib/restricted/googletest/googlemock/include/gmock/internal/gmock-pp.h
@@ -1,279 +1,279 @@
-#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
-#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
-
-// Expands and concatenates the arguments. Constructed macros reevaluate.
-#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)
-
-// Expands and stringifies the only argument.
-#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)
-
-// Returns empty. Given a variadic number of arguments.
-#define GMOCK_PP_EMPTY(...)
-
-// Returns a comma. Given a variadic number of arguments.
-#define GMOCK_PP_COMMA(...) ,
-
-// Returns the only argument.
-#define GMOCK_PP_IDENTITY(_1) _1
-
-// Evaluates to the number of arguments after expansion.
-//
-//   #define PAIR x, y
-//
-//   GMOCK_PP_NARG() => 1
-//   GMOCK_PP_NARG(x) => 1
-//   GMOCK_PP_NARG(x, y) => 2
-//   GMOCK_PP_NARG(PAIR) => 2
-//
-// Requires: the number of arguments after expansion is at most 15.
-#define GMOCK_PP_NARG(...) \
-  GMOCK_PP_INTERNAL_16TH(  \
-      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
-
-// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
-// returns 0. Requires no more than 15 unprotected commas.
-#define GMOCK_PP_HAS_COMMA(...) \
-  GMOCK_PP_INTERNAL_16TH(       \
-      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))
-
-// Returns the first argument.
-#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))
-
-// Returns the tail. A variadic list of all arguments minus the first. Requires
-// at least one argument.
-#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__))
-
-// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
-#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
-  GMOCK_PP_IDENTITY(                        \
-      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__))
-
-// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
-// evaluates to `0`.
-//
-// Requires: * the number of arguments after expansion is at most 15.
-//           * If the argument is a macro, it must be able to be called with one
-//             argument.
-//
-// Implementation details:
-//
-// There is one case when it generates a compile error: if the argument is macro
-// that cannot be called with one argument.
-//
-//   #define M(a, b)  // it doesn't matter what it expands to
-//
-//   // Expected: expands to `0`.
-//   // Actual: compile error.
-//   GMOCK_PP_IS_EMPTY(M)
-//
-// There are 4 cases tested:
-//
-// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
-// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0.
-// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma.
-//   Expected 0
-// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
-//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
-//
-// We trigger detection on '0001', i.e. on empty.
-#define GMOCK_PP_IS_EMPTY(...)                                               \
-  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \
-                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \
-                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \
-                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__()))
-
-// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
-#define GMOCK_PP_IF(_Cond, _Then, _Else) \
-  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)
-
-// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses.
-//
-// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c
-// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f
-//
-#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \
-  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else))
-
-// Evaluates to the number of arguments after expansion. Identifies 'empty' as
-// 0.
-//
-//   #define PAIR x, y
-//
-//   GMOCK_PP_NARG0() => 0
-//   GMOCK_PP_NARG0(x) => 1
-//   GMOCK_PP_NARG0(x, y) => 2
-//   GMOCK_PP_NARG0(PAIR) => 2
-//
-// Requires: * the number of arguments after expansion is at most 15.
-//           * If the argument is a macro, it must be able to be called with one
-//             argument.
-#define GMOCK_PP_NARG0(...) \
-  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__))
-
-// Expands to 1 if the first argument starts with something in parentheses,
-// otherwise to 0.
-#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \
-  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
-                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))
-
-// Expands to 1 is there is only one argument and it is enclosed in parentheses.
-#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \
-  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
-              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)
-
-// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
-#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__
-
-// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
-// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
-// Requires: * |_Macro| can be called with 3 arguments.
-//           * |_Tuple| expansion has no more than 15 elements.
-#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
-  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
-  (0, _Macro, _Data, _Tuple)
-
-// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
-// Empty if _K = 0.
-// Requires: * |_Macro| can be called with 3 arguments.
-//           * |_K| literal between 0 and 15
-#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
-  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
-  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
-
-// Increments the argument, requires the argument to be between 0 and 15.
-#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
-
-// Returns comma if _i != 0. Requires _i to be between 0 and 15.
-#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)
-
-// Internal details follow. Do not use any of these symbols outside of this
-// file or we will break your code.
-#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
-#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
-#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
-#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
-#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \
-  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \
-                                             _1, _2, _3, _4))
-#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
-#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
-#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else
-
-// Because of MSVC treating a token with a comma in it as a single token when
-// passed to another macro, we need to force it to evaluate it as multiple
-// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
-// define one per possible macro that relies on this behavior. Note "_Args" must
-// be parenthesized.
-#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
-                                        _10, _11, _12, _13, _14, _15, _16,  \
-                                        ...)                                \
-  _16
-#define GMOCK_PP_INTERNAL_16TH(_Args) \
-  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
-#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
-#define GMOCK_PP_INTERNAL_HEAD(_Args) \
-  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
-#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__
-#define GMOCK_PP_INTERNAL_TAIL(_Args) \
-  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args)
-
-#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
-#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
-#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
-  0,
-#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
-#define GMOCK_PP_INTERNAL_INC_0 1
-#define GMOCK_PP_INTERNAL_INC_1 2
-#define GMOCK_PP_INTERNAL_INC_2 3
-#define GMOCK_PP_INTERNAL_INC_3 4
-#define GMOCK_PP_INTERNAL_INC_4 5
-#define GMOCK_PP_INTERNAL_INC_5 6
-#define GMOCK_PP_INTERNAL_INC_6 7
-#define GMOCK_PP_INTERNAL_INC_7 8
-#define GMOCK_PP_INTERNAL_INC_8 9
-#define GMOCK_PP_INTERNAL_INC_9 10
-#define GMOCK_PP_INTERNAL_INC_10 11
-#define GMOCK_PP_INTERNAL_INC_11 12
-#define GMOCK_PP_INTERNAL_INC_12 13
-#define GMOCK_PP_INTERNAL_INC_13 14
-#define GMOCK_PP_INTERNAL_INC_14 15
-#define GMOCK_PP_INTERNAL_INC_15 16
-#define GMOCK_PP_INTERNAL_COMMA_IF_0
-#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
-#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
-#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
-  _Macro(_i, _Data, _element)
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \
-                                    (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \
-                                     (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \
-                                     (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \
-                                     (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \
-                                     (GMOCK_PP_TAIL _Tuple))
-#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \
-  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
-  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
-                                     (GMOCK_PP_TAIL _Tuple))
-
-#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ 
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ 
+ 
+// Expands and concatenates the arguments. Constructed macros reevaluate. 
+#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2) 
+ 
+// Expands and stringifies the only argument. 
+#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__) 
+ 
+// Returns empty. Given a variadic number of arguments. 
+#define GMOCK_PP_EMPTY(...) 
+ 
+// Returns a comma. Given a variadic number of arguments. 
+#define GMOCK_PP_COMMA(...) , 
+ 
+// Returns the only argument. 
+#define GMOCK_PP_IDENTITY(_1) _1 
+ 
+// Evaluates to the number of arguments after expansion. 
+// 
+//   #define PAIR x, y 
+// 
+//   GMOCK_PP_NARG() => 1 
+//   GMOCK_PP_NARG(x) => 1 
+//   GMOCK_PP_NARG(x, y) => 2 
+//   GMOCK_PP_NARG(PAIR) => 2 
+// 
+// Requires: the number of arguments after expansion is at most 15. 
+#define GMOCK_PP_NARG(...) \ 
+  GMOCK_PP_INTERNAL_16TH(  \ 
+      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) 
+ 
+// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise 
+// returns 0. Requires no more than 15 unprotected commas. 
+#define GMOCK_PP_HAS_COMMA(...) \ 
+  GMOCK_PP_INTERNAL_16TH(       \ 
+      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0)) 
+ 
+// Returns the first argument. 
+#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg)) 
+ 
+// Returns the tail. A variadic list of all arguments minus the first. Requires 
+// at least one argument. 
+#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__)) 
+ 
+// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__) 
+#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \ 
+  GMOCK_PP_IDENTITY(                        \ 
+      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__)) 
+ 
+// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise 
+// evaluates to `0`. 
+// 
+// Requires: * the number of arguments after expansion is at most 15. 
+//           * If the argument is a macro, it must be able to be called with one 
+//             argument. 
+// 
+// Implementation details: 
+// 
+// There is one case when it generates a compile error: if the argument is macro 
+// that cannot be called with one argument. 
+// 
+//   #define M(a, b)  // it doesn't matter what it expands to 
+// 
+//   // Expected: expands to `0`. 
+//   // Actual: compile error. 
+//   GMOCK_PP_IS_EMPTY(M) 
+// 
+// There are 4 cases tested: 
+// 
+// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0. 
+// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0. 
+// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma. 
+//   Expected 0 
+// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in 
+//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1. 
+// 
+// We trigger detection on '0001', i.e. on empty. 
+#define GMOCK_PP_IS_EMPTY(...)                                               \ 
+  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \ 
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \ 
+                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \ 
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__())) 
+ 
+// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0. 
+#define GMOCK_PP_IF(_Cond, _Then, _Else) \ 
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else) 
+ 
+// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses. 
+// 
+// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c 
+// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f 
+// 
+#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \ 
+  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else)) 
+ 
+// Evaluates to the number of arguments after expansion. Identifies 'empty' as 
+// 0. 
+// 
+//   #define PAIR x, y 
+// 
+//   GMOCK_PP_NARG0() => 0 
+//   GMOCK_PP_NARG0(x) => 1 
+//   GMOCK_PP_NARG0(x, y) => 2 
+//   GMOCK_PP_NARG0(PAIR) => 2 
+// 
+// Requires: * the number of arguments after expansion is at most 15. 
+//           * If the argument is a macro, it must be able to be called with one 
+//             argument. 
+#define GMOCK_PP_NARG0(...) \ 
+  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__)) 
+ 
+// Expands to 1 if the first argument starts with something in parentheses, 
+// otherwise to 0. 
+#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \ 
+  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \ 
+                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__)) 
+ 
+// Expands to 1 is there is only one argument and it is enclosed in parentheses. 
+#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \ 
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \ 
+              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0) 
+ 
+// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1. 
+#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__ 
+ 
+// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data, 
+// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple. 
+// Requires: * |_Macro| can be called with 3 arguments. 
+//           * |_Tuple| expansion has no more than 15 elements. 
+#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \ 
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \ 
+  (0, _Macro, _Data, _Tuple) 
+ 
+// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, ) 
+// Empty if _K = 0. 
+// Requires: * |_Macro| can be called with 3 arguments. 
+//           * |_K| literal between 0 and 15 
+#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \ 
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \ 
+  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE) 
+ 
+// Increments the argument, requires the argument to be between 0 and 15. 
+#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i) 
+ 
+// Returns comma if _i != 0. Requires _i to be between 0 and 15. 
+#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i) 
+ 
+// Internal details follow. Do not use any of these symbols outside of this 
+// file or we will break your code. 
+#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , ) 
+#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2 
+#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__ 
+#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5 
+#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \ 
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \ 
+                                             _1, _2, _3, _4)) 
+#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 , 
+#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then 
+#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else 
+ 
+// Because of MSVC treating a token with a comma in it as a single token when 
+// passed to another macro, we need to force it to evaluate it as multiple 
+// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We 
+// define one per possible macro that relies on this behavior. Note "_Args" must 
+// be parenthesized. 
+#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \ 
+                                        _10, _11, _12, _13, _14, _15, _16,  \ 
+                                        ...)                                \ 
+  _16 
+#define GMOCK_PP_INTERNAL_16TH(_Args) \ 
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args) 
+#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1 
+#define GMOCK_PP_INTERNAL_HEAD(_Args) \ 
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args) 
+#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__ 
+#define GMOCK_PP_INTERNAL_TAIL(_Args) \ 
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args) 
+ 
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _ 
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1, 
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \ 
+  0, 
+#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__ 
+#define GMOCK_PP_INTERNAL_INC_0 1 
+#define GMOCK_PP_INTERNAL_INC_1 2 
+#define GMOCK_PP_INTERNAL_INC_2 3 
+#define GMOCK_PP_INTERNAL_INC_3 4 
+#define GMOCK_PP_INTERNAL_INC_4 5 
+#define GMOCK_PP_INTERNAL_INC_5 6 
+#define GMOCK_PP_INTERNAL_INC_6 7 
+#define GMOCK_PP_INTERNAL_INC_7 8 
+#define GMOCK_PP_INTERNAL_INC_8 9 
+#define GMOCK_PP_INTERNAL_INC_9 10 
+#define GMOCK_PP_INTERNAL_INC_10 11 
+#define GMOCK_PP_INTERNAL_INC_11 12 
+#define GMOCK_PP_INTERNAL_INC_12 13 
+#define GMOCK_PP_INTERNAL_INC_13 14 
+#define GMOCK_PP_INTERNAL_INC_14 15 
+#define GMOCK_PP_INTERNAL_INC_15 16 
+#define GMOCK_PP_INTERNAL_COMMA_IF_0 
+#define GMOCK_PP_INTERNAL_COMMA_IF_1 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_2 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_3 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_4 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_5 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_6 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_7 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_8 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_9 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_10 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_11 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_12 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_13 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_14 , 
+#define GMOCK_PP_INTERNAL_COMMA_IF_15 , 
+#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \ 
+  _Macro(_i, _Data, _element) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \ 
+                                    (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \ 
+                                     (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \ 
+                                     (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \ 
+                                     (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \ 
+                                     (GMOCK_PP_TAIL _Tuple)) 
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \ 
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \ 
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \ 
+                                     (GMOCK_PP_TAIL _Tuple)) 
+ 
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_ 
diff --git a/contrib/restricted/googletest/googlemock/src/gmock-all.cc b/contrib/restricted/googletest/googlemock/src/gmock-all.cc
index e43c9b7b4c..6300ac9857 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock-all.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock-all.cc
@@ -26,7 +26,7 @@
 // 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.
-
+ 
 //
 // Google C++ Mocking Framework (Google Mock)
 //
diff --git a/contrib/restricted/googletest/googlemock/src/gmock-cardinalities.cc b/contrib/restricted/googletest/googlemock/src/gmock-cardinalities.cc
index 7463f43832..05e138af6a 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock-cardinalities.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock-cardinalities.cc
@@ -27,7 +27,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements cardinalities.
@@ -70,18 +70,18 @@ class BetweenCardinalityImpl : public CardinalityInterface {
 
   // Conservative estimate on the lower/upper bound of the number of
   // calls allowed.
-  int ConservativeLowerBound() const override { return min_; }
-  int ConservativeUpperBound() const override { return max_; }
+  int ConservativeLowerBound() const override { return min_; } 
+  int ConservativeUpperBound() const override { return max_; } 
 
-  bool IsSatisfiedByCallCount(int call_count) const override {
+  bool IsSatisfiedByCallCount(int call_count) const override { 
     return min_ <= call_count && call_count <= max_;
   }
 
-  bool IsSaturatedByCallCount(int call_count) const override {
+  bool IsSaturatedByCallCount(int call_count) const override { 
     return call_count >= max_;
   }
 
-  void DescribeTo(::std::ostream* os) const override;
+  void DescribeTo(::std::ostream* os) const override; 
 
  private:
   const int min_;
@@ -91,7 +91,7 @@ class BetweenCardinalityImpl : public CardinalityInterface {
 };
 
 // Formats "n times" in a human-friendly way.
-inline std::string FormatTimes(int n) {
+inline std::string FormatTimes(int n) { 
   if (n == 1) {
     return "once";
   } else if (n == 2) {
diff --git a/contrib/restricted/googletest/googlemock/src/gmock-internal-utils.cc b/contrib/restricted/googletest/googlemock/src/gmock-internal-utils.cc
index e5b547981d..42dab1cd55 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock-internal-utils.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock-internal-utils.cc
@@ -27,7 +27,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file defines some utilities useful for implementing Google
@@ -46,31 +46,31 @@
 namespace testing {
 namespace internal {
 
-// Joins a vector of strings as if they are fields of a tuple; returns
-// the joined string.
-GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
-  switch (fields.size()) {
-    case 0:
-      return "";
-    case 1:
-      return fields[0];
-    default:
-      std::string result = "(" + fields[0];
-      for (size_t i = 1; i < fields.size(); i++) {
-        result += ", ";
-        result += fields[i];
-      }
-      result += ")";
-      return result;
-  }
-}
-
+// Joins a vector of strings as if they are fields of a tuple; returns 
+// the joined string. 
+GTEST_API_ std::string JoinAsTuple(const Strings& fields) { 
+  switch (fields.size()) { 
+    case 0: 
+      return ""; 
+    case 1: 
+      return fields[0]; 
+    default: 
+      std::string result = "(" + fields[0]; 
+      for (size_t i = 1; i < fields.size(); i++) { 
+        result += ", "; 
+        result += fields[i]; 
+      } 
+      result += ")"; 
+      return result; 
+  } 
+} 
+ 
 // Converts an identifier name to a space-separated list of lower-case
 // words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
 // treated as one word.  For example, both "FooBar123" and
 // "foo_bar_123" are converted to "foo bar 123".
-GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
-  std::string result;
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) { 
+  std::string result; 
   char prev_char = '\0';
   for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
     // We don't care about the current locale as the input is
@@ -89,12 +89,12 @@ GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
 }
 
 // This class reports Google Mock failures as Google Test failures.  A
-// user can define another class in a similar fashion if they intend to
+// user can define another class in a similar fashion if they intend to 
 // use Google Mock with a testing framework other than Google Test.
 class GoogleTestFailureReporter : public FailureReporterInterface {
  public:
-  void ReportFailure(FailureType type, const char* file, int line,
-                     const std::string& message) override {
+  void ReportFailure(FailureType type, const char* file, int line, 
+                     const std::string& message) override { 
     AssertHelper(type == kFatal ?
                  TestPartResult::kFatalFailure :
                  TestPartResult::kNonFatalFailure,
@@ -123,8 +123,8 @@ GTEST_API_ FailureReporterInterface* GetFailureReporter() {
 // Protects global resources (stdout in particular) used by Log().
 static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
 
-// Returns true if and only if a log with the given severity is visible
-// according to the --gmock_verbose flag.
+// Returns true if and only if a log with the given severity is visible 
+// according to the --gmock_verbose flag. 
 GTEST_API_ bool LogIsVisible(LogSeverity severity) {
   if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
     // Always show the log if --gmock_verbose=info.
@@ -139,14 +139,14 @@ GTEST_API_ bool LogIsVisible(LogSeverity severity) {
   }
 }
 
-// Prints the given message to stdout if and only if 'severity' >= the level
+// Prints the given message to stdout if and only if 'severity' >= the level 
 // specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
 // 0, also prints the stack trace excluding the top
 // stack_frames_to_skip frames.  In opt mode, any positive
 // stack_frames_to_skip is treated as 0, since we don't know which
 // function calls will be inlined by the compiler and need to be
 // conservative.
-GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+GTEST_API_ void Log(LogSeverity severity, const std::string& message, 
                     int stack_frames_to_skip) {
   if (!LogIsVisible(severity))
     return;
@@ -184,17 +184,17 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
   std::cout << ::std::flush;
 }
 
-GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }
-
-GTEST_API_ void IllegalDoDefault(const char* file, int line) {
-  internal::Assert(
-      false, file, line,
-      "You are using DoDefault() inside a composite action like "
-      "DoAll() or WithArgs().  This is not supported for technical "
-      "reasons.  Please instead spell out the default action, or "
-      "assign the default action to an Action variable and use "
-      "the variable in various places.");
-}
-
+GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); } 
+ 
+GTEST_API_ void IllegalDoDefault(const char* file, int line) { 
+  internal::Assert( 
+      false, file, line, 
+      "You are using DoDefault() inside a composite action like " 
+      "DoAll() or WithArgs().  This is not supported for technical " 
+      "reasons.  Please instead spell out the default action, or " 
+      "assign the default action to an Action variable and use " 
+      "the variable in various places."); 
+} 
+ 
 }  // namespace internal
 }  // namespace testing
diff --git a/contrib/restricted/googletest/googlemock/src/gmock-matchers.cc b/contrib/restricted/googletest/googlemock/src/gmock-matchers.cc
index dded437add..37625e5058 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock-matchers.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock-matchers.cc
@@ -27,7 +27,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements Matcher<const string&>, Matcher<string>, and
@@ -36,7 +36,7 @@
 #include "gmock/gmock-matchers.h"
 
 #include <string.h>
-#include <iostream>
+#include <iostream> 
 #include <sstream>
 #include <string>
 
@@ -48,11 +48,11 @@ namespace internal {
 // 'negation' is false; otherwise returns the description of the
 // negation of the matcher.  'param_values' contains a list of strings
 // that are the print-out of the matcher's parameters.
-GTEST_API_ std::string FormatMatcherDescription(bool negation,
-                                                const char* matcher_name,
-                                                const Strings& param_values) {
-  std::string result = ConvertIdentifierNameToWords(matcher_name);
-  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
+GTEST_API_ std::string FormatMatcherDescription(bool negation, 
+                                                const char* matcher_name, 
+                                                const Strings& param_values) { 
+  std::string result = ConvertIdentifierNameToWords(matcher_name); 
+  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values); 
   return negation ? "not (" + result + ")" : result;
 }
 
@@ -123,7 +123,7 @@ class MaxBipartiteMatchState {
   explicit MaxBipartiteMatchState(const MatchMatrix& graph)
       : graph_(&graph),
         left_(graph_->LhsSize(), kUnused),
-        right_(graph_->RhsSize(), kUnused) {}
+        right_(graph_->RhsSize(), kUnused) {} 
 
   // Returns the edges of a maximal match, each in the form {left, right}.
   ElementMatcherPairs Compute() {
@@ -180,8 +180,8 @@ class MaxBipartiteMatchState {
   //
   bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
     for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
-      if ((*seen)[irhs]) continue;
-      if (!graph_->HasEdge(ilhs, irhs)) continue;
+      if ((*seen)[irhs]) continue; 
+      if (!graph_->HasEdge(ilhs, irhs)) continue; 
       // There's an available edge from ilhs to irhs.
       (*seen)[irhs] = 1;
       // Next a search is performed to determine whether
@@ -208,7 +208,7 @@ class MaxBipartiteMatchState {
   // Each element of the left_ vector represents a left hand side node
   // (i.e. an element) and each element of right_ is a right hand side
   // node (i.e. a matcher). The values in the left_ vector indicate
-  // outflow from that node to a node on the right_ side. The values
+  // outflow from that node to a node on the right_ side. The values 
   // in the right_ indicate inflow, and specify which left_ node is
   // feeding that right_ node, if any. For example, left_[3] == 1 means
   // there's a flow from element #3 to matcher #1. Such a flow would also
@@ -222,7 +222,7 @@ class MaxBipartiteMatchState {
 
 const size_t MaxBipartiteMatchState::kUnused;
 
-GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) {
+GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) { 
   return MaxBipartiteMatchState(g).Compute();
 }
 
@@ -231,7 +231,7 @@ static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
   typedef ElementMatcherPairs::const_iterator Iter;
   ::std::ostream& os = *stream;
   os << "{";
-  const char* sep = "";
+  const char* sep = ""; 
   for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
     os << sep << "\n  ("
        << "element #" << it->first << ", "
@@ -264,9 +264,9 @@ void MatchMatrix::Randomize() {
   }
 }
 
-std::string MatchMatrix::DebugString() const {
+std::string MatchMatrix::DebugString() const { 
   ::std::stringstream ss;
-  const char* sep = "";
+  const char* sep = ""; 
   for (size_t i = 0; i < LhsSize(); ++i) {
     ss << sep;
     for (size_t j = 0; j < RhsSize(); ++j) {
@@ -279,83 +279,83 @@ std::string MatchMatrix::DebugString() const {
 
 void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
     ::std::ostream* os) const {
-  switch (match_flags()) {
-    case UnorderedMatcherRequire::ExactMatch:
-      if (matcher_describers_.empty()) {
-        *os << "is empty";
-        return;
-      }
-      if (matcher_describers_.size() == 1) {
-        *os << "has " << Elements(1) << " and that element ";
-        matcher_describers_[0]->DescribeTo(os);
-        return;
-      }
-      *os << "has " << Elements(matcher_describers_.size())
-          << " and there exists some permutation of elements such that:\n";
-      break;
-    case UnorderedMatcherRequire::Superset:
-      *os << "a surjection from elements to requirements exists such that:\n";
-      break;
-    case UnorderedMatcherRequire::Subset:
-      *os << "an injection from elements to requirements exists such that:\n";
-      break;
+  switch (match_flags()) { 
+    case UnorderedMatcherRequire::ExactMatch: 
+      if (matcher_describers_.empty()) { 
+        *os << "is empty"; 
+        return; 
+      } 
+      if (matcher_describers_.size() == 1) { 
+        *os << "has " << Elements(1) << " and that element "; 
+        matcher_describers_[0]->DescribeTo(os); 
+        return; 
+      } 
+      *os << "has " << Elements(matcher_describers_.size()) 
+          << " and there exists some permutation of elements such that:\n"; 
+      break; 
+    case UnorderedMatcherRequire::Superset: 
+      *os << "a surjection from elements to requirements exists such that:\n"; 
+      break; 
+    case UnorderedMatcherRequire::Subset: 
+      *os << "an injection from elements to requirements exists such that:\n"; 
+      break; 
   }
-
+ 
   const char* sep = "";
   for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep;
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      *os << " - element #" << i << " ";
-    } else {
-      *os << " - an element ";
-    }
+    *os << sep; 
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) { 
+      *os << " - element #" << i << " "; 
+    } else { 
+      *os << " - an element "; 
+    } 
     matcher_describers_[i]->DescribeTo(os);
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      sep = ", and\n";
-    } else {
-      sep = "\n";
-    }
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) { 
+      sep = ", and\n"; 
+    } else { 
+      sep = "\n"; 
+    } 
   }
 }
 
 void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
     ::std::ostream* os) const {
-  switch (match_flags()) {
-    case UnorderedMatcherRequire::ExactMatch:
-      if (matcher_describers_.empty()) {
-        *os << "isn't empty";
-        return;
-      }
-      if (matcher_describers_.size() == 1) {
-        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
-            << " that ";
-        matcher_describers_[0]->DescribeNegationTo(os);
-        return;
-      }
-      *os << "doesn't have " << Elements(matcher_describers_.size())
-          << ", or there exists no permutation of elements such that:\n";
-      break;
-    case UnorderedMatcherRequire::Superset:
-      *os << "no surjection from elements to requirements exists such that:\n";
-      break;
-    case UnorderedMatcherRequire::Subset:
-      *os << "no injection from elements to requirements exists such that:\n";
-      break;
+  switch (match_flags()) { 
+    case UnorderedMatcherRequire::ExactMatch: 
+      if (matcher_describers_.empty()) { 
+        *os << "isn't empty"; 
+        return; 
+      } 
+      if (matcher_describers_.size() == 1) { 
+        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1) 
+            << " that "; 
+        matcher_describers_[0]->DescribeNegationTo(os); 
+        return; 
+      } 
+      *os << "doesn't have " << Elements(matcher_describers_.size()) 
+          << ", or there exists no permutation of elements such that:\n"; 
+      break; 
+    case UnorderedMatcherRequire::Superset: 
+      *os << "no surjection from elements to requirements exists such that:\n"; 
+      break; 
+    case UnorderedMatcherRequire::Subset: 
+      *os << "no injection from elements to requirements exists such that:\n"; 
+      break; 
   }
   const char* sep = "";
   for (size_t i = 0; i != matcher_describers_.size(); ++i) {
-    *os << sep;
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      *os << " - element #" << i << " ";
-    } else {
-      *os << " - an element ";
-    }
+    *os << sep; 
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) { 
+      *os << " - element #" << i << " "; 
+    } else { 
+      *os << " - an element "; 
+    } 
     matcher_describers_[i]->DescribeTo(os);
-    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
-      sep = ", and\n";
-    } else {
-      sep = "\n";
-    }
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) { 
+      sep = ", and\n"; 
+    } else { 
+      sep = "\n"; 
+    } 
   }
 }
 
@@ -364,9 +364,9 @@ void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
 // and better error reporting.
 // Returns false, writing an explanation to 'listener', if and only
 // if the success criteria are not met.
-bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
-    const ::std::vector<std::string>& element_printouts,
-    const MatchMatrix& matrix, MatchResultListener* listener) const {
+bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix( 
+    const ::std::vector<std::string>& element_printouts, 
+    const MatchMatrix& matrix, MatchResultListener* listener) const { 
   bool result = true;
   ::std::vector<char> element_matched(matrix.LhsSize(), 0);
   ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
@@ -379,11 +379,11 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
     }
   }
 
-  if (match_flags() & UnorderedMatcherRequire::Superset) {
+  if (match_flags() & UnorderedMatcherRequire::Superset) { 
     const char* sep =
         "where the following matchers don't match any elements:\n";
     for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
-      if (matcher_matched[mi]) continue;
+      if (matcher_matched[mi]) continue; 
       result = false;
       if (listener->IsInterested()) {
         *listener << sep << "matcher #" << mi << ": ";
@@ -393,7 +393,7 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
     }
   }
 
-  if (match_flags() & UnorderedMatcherRequire::Subset) {
+  if (match_flags() & UnorderedMatcherRequire::Subset) { 
     const char* sep =
         "where the following elements don't match any matchers:\n";
     const char* outer_sep = "";
@@ -401,7 +401,7 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
       outer_sep = "\nand ";
     }
     for (size_t ei = 0; ei < element_matched.size(); ++ei) {
-      if (element_matched[ei]) continue;
+      if (element_matched[ei]) continue; 
       result = false;
       if (listener->IsInterested()) {
         *listener << outer_sep << sep << "element #" << ei << ": "
@@ -414,46 +414,46 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
   return result;
 }
 
-bool UnorderedElementsAreMatcherImplBase::FindPairing(
-    const MatchMatrix& matrix, MatchResultListener* listener) const {
-  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
-
-  size_t max_flow = matches.size();
-  if ((match_flags() & UnorderedMatcherRequire::Superset) &&
-      max_flow < matrix.RhsSize()) {
-    if (listener->IsInterested()) {
-      *listener << "where no permutation of the elements can satisfy all "
-                   "matchers, and the closest match is "
-                << max_flow << " of " << matrix.RhsSize()
-                << " matchers with the pairings:\n";
-      LogElementMatcherPairVec(matches, listener->stream());
-    }
-    return false;
-  }
-  if ((match_flags() & UnorderedMatcherRequire::Subset) &&
-      max_flow < matrix.LhsSize()) {
-    if (listener->IsInterested()) {
-      *listener
-          << "where not all elements can be matched, and the closest match is "
-          << max_flow << " of " << matrix.RhsSize()
-          << " matchers with the pairings:\n";
-      LogElementMatcherPairVec(matches, listener->stream());
-    }
-    return false;
-  }
-
-  if (matches.size() > 1) {
-    if (listener->IsInterested()) {
-      const char* sep = "where:\n";
-      for (size_t mi = 0; mi < matches.size(); ++mi) {
-        *listener << sep << " - element #" << matches[mi].first
-                  << " is matched by matcher #" << matches[mi].second;
-        sep = ",\n";
-      }
-    }
-  }
-  return true;
-}
-
+bool UnorderedElementsAreMatcherImplBase::FindPairing( 
+    const MatchMatrix& matrix, MatchResultListener* listener) const { 
+  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix); 
+ 
+  size_t max_flow = matches.size(); 
+  if ((match_flags() & UnorderedMatcherRequire::Superset) && 
+      max_flow < matrix.RhsSize()) { 
+    if (listener->IsInterested()) { 
+      *listener << "where no permutation of the elements can satisfy all " 
+                   "matchers, and the closest match is " 
+                << max_flow << " of " << matrix.RhsSize() 
+                << " matchers with the pairings:\n"; 
+      LogElementMatcherPairVec(matches, listener->stream()); 
+    } 
+    return false; 
+  } 
+  if ((match_flags() & UnorderedMatcherRequire::Subset) && 
+      max_flow < matrix.LhsSize()) { 
+    if (listener->IsInterested()) { 
+      *listener 
+          << "where not all elements can be matched, and the closest match is " 
+          << max_flow << " of " << matrix.RhsSize() 
+          << " matchers with the pairings:\n"; 
+      LogElementMatcherPairVec(matches, listener->stream()); 
+    } 
+    return false; 
+  } 
+ 
+  if (matches.size() > 1) { 
+    if (listener->IsInterested()) { 
+      const char* sep = "where:\n"; 
+      for (size_t mi = 0; mi < matches.size(); ++mi) { 
+        *listener << sep << " - element #" << matches[mi].first 
+                  << " is matched by matcher #" << matches[mi].second; 
+        sep = ",\n"; 
+      } 
+    } 
+  } 
+  return true; 
+} 
+ 
 }  // namespace internal
 }  // namespace testing
diff --git a/contrib/restricted/googletest/googlemock/src/gmock-spec-builders.cc b/contrib/restricted/googletest/googlemock/src/gmock-spec-builders.cc
index c7266a3704..c5fc847ad4 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock-spec-builders.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock-spec-builders.cc
@@ -27,7 +27,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Google Mock - a framework for writing C++ mock classes.
 //
 // This file implements the spec builder syntax (ON_CALL and
@@ -36,31 +36,31 @@
 #include "gmock/gmock-spec-builders.h"
 
 #include <stdlib.h>
-
+ 
 #include <iostream>  // NOLINT
 #include <map>
-#include <memory>
+#include <memory> 
 #include <set>
 #include <string>
-#include <vector>
-
+#include <vector> 
+ 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-port.h" 
 
 #if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
 # include <unistd.h>  // NOLINT
 #endif
 
-// Silence C4800 (C4800: 'int *const ': forcing value
-// to bool 'true' or 'false') for MSVC 15
-#ifdef _MSC_VER
-#if _MSC_VER == 1900
-#  pragma warning(push)
-#  pragma warning(disable:4800)
-#endif
-#endif
-
+// Silence C4800 (C4800: 'int *const ': forcing value 
+// to bool 'true' or 'false') for MSVC 15 
+#ifdef _MSC_VER 
+#if _MSC_VER == 1900 
+#  pragma warning(push) 
+#  pragma warning(disable:4800) 
+#endif 
+#endif 
+ 
 namespace testing {
 namespace internal {
 
@@ -71,16 +71,16 @@ GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
 // Logs a message including file and line number information.
 GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
                                 const char* file, int line,
-                                const std::string& message) {
+                                const std::string& message) { 
   ::std::ostringstream s;
-  s << internal::FormatFileLocation(file, line) << " " << message
-    << ::std::endl;
+  s << internal::FormatFileLocation(file, line) << " " << message 
+    << ::std::endl; 
   Log(severity, s.str(), 0);
 }
 
 // Constructs an ExpectationBase object.
-ExpectationBase::ExpectationBase(const char* a_file, int a_line,
-                                 const std::string& a_source_text)
+ExpectationBase::ExpectationBase(const char* a_file, int a_line, 
+                                 const std::string& a_source_text) 
     : file_(a_file),
       line_(a_line),
       source_text_(a_source_text),
@@ -113,40 +113,40 @@ void ExpectationBase::RetireAllPreRequisites()
     return;
   }
 
-  ::std::vector<ExpectationBase*> expectations(1, this);
-  while (!expectations.empty()) {
-    ExpectationBase* exp = expectations.back();
-    expectations.pop_back();
-
-    for (ExpectationSet::const_iterator it =
-             exp->immediate_prerequisites_.begin();
-         it != exp->immediate_prerequisites_.end(); ++it) {
-      ExpectationBase* next = it->expectation_base().get();
-      if (!next->is_retired()) {
-        next->Retire();
-        expectations.push_back(next);
-      }
+  ::std::vector<ExpectationBase*> expectations(1, this); 
+  while (!expectations.empty()) { 
+    ExpectationBase* exp = expectations.back(); 
+    expectations.pop_back(); 
+ 
+    for (ExpectationSet::const_iterator it = 
+             exp->immediate_prerequisites_.begin(); 
+         it != exp->immediate_prerequisites_.end(); ++it) { 
+      ExpectationBase* next = it->expectation_base().get(); 
+      if (!next->is_retired()) { 
+        next->Retire(); 
+        expectations.push_back(next); 
+      } 
     }
   }
 }
 
-// Returns true if and only if all pre-requisites of this expectation
-// have been satisfied.
+// Returns true if and only if all pre-requisites of this expectation 
+// have been satisfied. 
 bool ExpectationBase::AllPrerequisitesAreSatisfied() const
     GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
   g_gmock_mutex.AssertHeld();
-  ::std::vector<const ExpectationBase*> expectations(1, this);
-  while (!expectations.empty()) {
-    const ExpectationBase* exp = expectations.back();
-    expectations.pop_back();
-
-    for (ExpectationSet::const_iterator it =
-             exp->immediate_prerequisites_.begin();
-         it != exp->immediate_prerequisites_.end(); ++it) {
-      const ExpectationBase* next = it->expectation_base().get();
-      if (!next->IsSatisfied()) return false;
-      expectations.push_back(next);
-    }
+  ::std::vector<const ExpectationBase*> expectations(1, this); 
+  while (!expectations.empty()) { 
+    const ExpectationBase* exp = expectations.back(); 
+    expectations.pop_back(); 
+ 
+    for (ExpectationSet::const_iterator it = 
+             exp->immediate_prerequisites_.begin(); 
+         it != exp->immediate_prerequisites_.end(); ++it) { 
+      const ExpectationBase* next = it->expectation_base().get(); 
+      if (!next->IsSatisfied()) return false; 
+      expectations.push_back(next); 
+    } 
   }
   return true;
 }
@@ -155,27 +155,27 @@ bool ExpectationBase::AllPrerequisitesAreSatisfied() const
 void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
     GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
   g_gmock_mutex.AssertHeld();
-  ::std::vector<const ExpectationBase*> expectations(1, this);
-  while (!expectations.empty()) {
-    const ExpectationBase* exp = expectations.back();
-    expectations.pop_back();
-
-    for (ExpectationSet::const_iterator it =
-             exp->immediate_prerequisites_.begin();
-         it != exp->immediate_prerequisites_.end(); ++it) {
-      const ExpectationBase* next = it->expectation_base().get();
-
-      if (next->IsSatisfied()) {
-        // If *it is satisfied and has a call count of 0, some of its
-        // pre-requisites may not be satisfied yet.
-        if (next->call_count_ == 0) {
-          expectations.push_back(next);
-        }
-      } else {
-        // Now that we know next is unsatisfied, we are not so interested
-        // in whether its pre-requisites are satisfied.  Therefore we
-        // don't iterate into it here.
-        *result += *it;
+  ::std::vector<const ExpectationBase*> expectations(1, this); 
+  while (!expectations.empty()) { 
+    const ExpectationBase* exp = expectations.back(); 
+    expectations.pop_back(); 
+ 
+    for (ExpectationSet::const_iterator it = 
+             exp->immediate_prerequisites_.begin(); 
+         it != exp->immediate_prerequisites_.end(); ++it) { 
+      const ExpectationBase* next = it->expectation_base().get(); 
+ 
+      if (next->IsSatisfied()) { 
+        // If *it is satisfied and has a call count of 0, some of its 
+        // pre-requisites may not be satisfied yet. 
+        if (next->call_count_ == 0) { 
+          expectations.push_back(next); 
+        } 
+      } else { 
+        // Now that we know next is unsatisfied, we are not so interested 
+        // in whether its pre-requisites are satisfied.  Therefore we 
+        // don't iterate into it here. 
+        *result += *it; 
       }
     }
   }
@@ -280,7 +280,7 @@ GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
 
 // Reports an uninteresting call (whose description is in msg) in the
 // manner specified by 'reaction'.
-void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg) { 
   // Include a stack trace only if --gmock_verbose=info is specified.
   const int stack_frames_to_skip =
       GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
@@ -291,22 +291,22 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
     case kWarn:
       Log(kWarning,
           msg +
-              "\nNOTE: You can safely ignore the above warning unless this "
-              "call should not happen.  Do not suppress it by blindly adding "
-              "an EXPECT_CALL() if you don't mean to enforce the call.  "
-              "See "
-              "https://github.com/google/googletest/blob/master/docs/"
-              "gmock_cook_book.md#"
-              "knowing-when-to-expect for details.\n",
+              "\nNOTE: You can safely ignore the above warning unless this " 
+              "call should not happen.  Do not suppress it by blindly adding " 
+              "an EXPECT_CALL() if you don't mean to enforce the call.  " 
+              "See " 
+              "https://github.com/google/googletest/blob/master/docs/" 
+              "gmock_cook_book.md#" 
+              "knowing-when-to-expect for details.\n", 
           stack_frames_to_skip);
       break;
     default:  // FAIL
-      Expect(false, nullptr, -1, msg);
+      Expect(false, nullptr, -1, msg); 
   }
 }
 
 UntypedFunctionMockerBase::UntypedFunctionMockerBase()
-    : mock_obj_(nullptr), name_("") {}
+    : mock_obj_(nullptr), name_("") {} 
 
 UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
 
@@ -345,7 +345,7 @@ const void* UntypedFunctionMockerBase::MockObject() const
     // We protect mock_obj_ under g_gmock_mutex in case this mock
     // function is called from two threads concurrently.
     MutexLock l(&g_gmock_mutex);
-    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
+    Assert(mock_obj_ != nullptr, __FILE__, __LINE__, 
            "MockObject() must not be called before RegisterOwner() or "
            "SetOwnerAndName() has been called.");
     mock_obj = mock_obj_;
@@ -362,7 +362,7 @@ const char* UntypedFunctionMockerBase::Name() const
     // We protect name_ under g_gmock_mutex in case this mock
     // function is called from two threads concurrently.
     MutexLock l(&g_gmock_mutex);
-    Assert(name_ != nullptr, __FILE__, __LINE__,
+    Assert(name_ != nullptr, __FILE__, __LINE__, 
            "Name() must not be called before SetOwnerAndName() has "
            "been called.");
     name = name_;
@@ -373,10 +373,10 @@ const char* UntypedFunctionMockerBase::Name() const
 // Calculates the result of invoking this mock function with the given
 // arguments, prints it, and returns it.  The caller is responsible
 // for deleting the result.
-UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
-    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-  // See the definition of untyped_expectations_ for why access to it
-  // is unprotected here.
+UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith( 
+    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { 
+  // See the definition of untyped_expectations_ for why access to it 
+  // is unprotected here. 
   if (untyped_expectations_.size() == 0) {
     // No expectation is set on this mock method - we have an
     // uninteresting call.
@@ -388,26 +388,26 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
     const CallReaction reaction =
         Mock::GetReactionOnUninterestingCalls(MockObject());
 
-    // True if and only if we need to print this call's arguments and return
+    // True if and only if we need to print this call's arguments and return 
     // value.  This definition must be kept in sync with
     // the behavior of ReportUninterestingCall().
     const bool need_to_report_uninteresting_call =
         // If the user allows this uninteresting call, we print it
-        // only when they want informational messages.
+        // only when they want informational messages. 
         reaction == kAllow ? LogIsVisible(kInfo) :
-                           // If the user wants this to be a warning, we print
-                           // it only when they want to see warnings.
-            reaction == kWarn
-                ? LogIsVisible(kWarning)
-                :
-                // Otherwise, the user wants this to be an error, and we
-                // should always print detailed information in the error.
-                true;
+                           // If the user wants this to be a warning, we print 
+                           // it only when they want to see warnings. 
+            reaction == kWarn 
+                ? LogIsVisible(kWarning) 
+                : 
+                // Otherwise, the user wants this to be an error, and we 
+                // should always print detailed information in the error. 
+                true; 
 
     if (!need_to_report_uninteresting_call) {
       // Perform the action without printing the call information.
-      return this->UntypedPerformDefaultAction(
-          untyped_args, "Function call: " + std::string(Name()));
+      return this->UntypedPerformDefaultAction( 
+          untyped_args, "Function call: " + std::string(Name())); 
     }
 
     // Warns about the uninteresting call.
@@ -419,7 +419,7 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
         this->UntypedPerformDefaultAction(untyped_args, ss.str());
 
     // Prints the function result.
-    if (result != nullptr) result->PrintAsActionResult(&ss);
+    if (result != nullptr) result->PrintAsActionResult(&ss); 
 
     ReportUninterestingCall(reaction, ss.str());
     return result;
@@ -429,27 +429,27 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
   ::std::stringstream ss;
   ::std::stringstream why;
   ::std::stringstream loc;
-  const void* untyped_action = nullptr;
+  const void* untyped_action = nullptr; 
 
   // The UntypedFindMatchingExpectation() function acquires and
   // releases g_gmock_mutex.
-
+ 
   const ExpectationBase* const untyped_expectation =
-      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
-                                           &is_excessive, &ss, &why);
-  const bool found = untyped_expectation != nullptr;
+      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action, 
+                                           &is_excessive, &ss, &why); 
+  const bool found = untyped_expectation != nullptr; 
 
-  // True if and only if we need to print the call's arguments
-  // and return value.
+  // True if and only if we need to print the call's arguments 
+  // and return value. 
   // This definition must be kept in sync with the uses of Expect()
   // and Log() in this function.
   const bool need_to_report_call =
       !found || is_excessive || LogIsVisible(kInfo);
   if (!need_to_report_call) {
     // Perform the action without printing the call information.
-    return untyped_action == nullptr
-               ? this->UntypedPerformDefaultAction(untyped_args, "")
-               : this->UntypedPerformAction(untyped_action, untyped_args);
+    return untyped_action == nullptr 
+               ? this->UntypedPerformDefaultAction(untyped_args, "") 
+               : this->UntypedPerformAction(untyped_action, untyped_args); 
   }
 
   ss << "    Function call: " << Name();
@@ -461,50 +461,50 @@ UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
     untyped_expectation->DescribeLocationTo(&loc);
   }
 
-  UntypedActionResultHolderBase* result = nullptr;
-
-  auto perform_action = [&] {
-    return untyped_action == nullptr
-               ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
-               : this->UntypedPerformAction(untyped_action, untyped_args);
-  };
-  auto handle_failures = [&] {
-    ss << "\n" << why.str();
-
-    if (!found) {
-      // No expectation matches this call - reports a failure.
-      Expect(false, nullptr, -1, ss.str());
-    } else if (is_excessive) {
-      // We had an upper-bound violation and the failure message is in ss.
-      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
-             ss.str());
-    } else {
-      // We had an expected call and the matching expectation is
-      // described in ss.
-      Log(kInfo, loc.str() + ss.str(), 2);
-    }
-  };
-#if GTEST_HAS_EXCEPTIONS
-  try {
-    result = perform_action();
-  } catch (...) {
-    handle_failures();
-    throw;
+  UntypedActionResultHolderBase* result = nullptr; 
+
+  auto perform_action = [&] { 
+    return untyped_action == nullptr 
+               ? this->UntypedPerformDefaultAction(untyped_args, ss.str()) 
+               : this->UntypedPerformAction(untyped_action, untyped_args); 
+  }; 
+  auto handle_failures = [&] { 
+    ss << "\n" << why.str(); 
+ 
+    if (!found) { 
+      // No expectation matches this call - reports a failure. 
+      Expect(false, nullptr, -1, ss.str()); 
+    } else if (is_excessive) { 
+      // We had an upper-bound violation and the failure message is in ss. 
+      Expect(false, untyped_expectation->file(), untyped_expectation->line(), 
+             ss.str()); 
+    } else { 
+      // We had an expected call and the matching expectation is 
+      // described in ss. 
+      Log(kInfo, loc.str() + ss.str(), 2); 
+    } 
+  }; 
+#if GTEST_HAS_EXCEPTIONS 
+  try { 
+    result = perform_action(); 
+  } catch (...) { 
+    handle_failures(); 
+    throw; 
   }
-#else
-  result = perform_action();
-#endif
+#else 
+  result = perform_action(); 
+#endif 
 
-  if (result != nullptr) result->PrintAsActionResult(&ss);
-  handle_failures();
+  if (result != nullptr) result->PrintAsActionResult(&ss); 
+  handle_failures(); 
   return result;
 }
 
 // Returns an Expectation object that references and co-owns exp,
 // which must be an expectation on this mock function.
 Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
-  // See the definition of untyped_expectations_ for why access to it
-  // is unprotected here.
+  // See the definition of untyped_expectations_ for why access to it 
+  // is unprotected here. 
   for (UntypedExpectations::const_iterator it =
            untyped_expectations_.begin();
        it != untyped_expectations_.end(); ++it) {
@@ -567,13 +567,13 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
   return expectations_met;
 }
 
-CallReaction intToCallReaction(int mock_behavior) {
-  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
-    return static_cast<internal::CallReaction>(mock_behavior);
-  }
-  return kWarn;
-}
-
+CallReaction intToCallReaction(int mock_behavior) { 
+  if (mock_behavior >= kAllow && mock_behavior <= kFail) { 
+    return static_cast<internal::CallReaction>(mock_behavior); 
+  } 
+  return kWarn; 
+} 
+ 
 }  // namespace internal
 
 // Class Mock.
@@ -587,15 +587,15 @@ typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
 // expectations.
 struct MockObjectState {
   MockObjectState()
-      : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
+      : first_used_file(nullptr), first_used_line(-1), leakable(false) {} 
 
   // Where in the source file an ON_CALL or EXPECT_CALL is first
   // invoked on this mock object.
   const char* first_used_file;
   int first_used_line;
-  ::std::string first_used_test_suite;
+  ::std::string first_used_test_suite; 
   ::std::string first_used_test;
-  bool leakable;  // true if and only if it's OK to leak the object.
+  bool leakable;  // true if and only if it's OK to leak the object. 
   FunctionMockers function_mockers;  // All registered methods of the object.
 };
 
@@ -622,7 +622,7 @@ class MockObjectRegistry {
       if (it->second.leakable)  // The user said it's fine to leak this object.
         continue;
 
-      // FIXME: Print the type of the leaked object.
+      // FIXME: Print the type of the leaked object. 
       // This can help the user identify the leaked object.
       std::cout << "\n";
       const MockObjectState& state = it->second;
@@ -630,23 +630,23 @@ class MockObjectRegistry {
                                                 state.first_used_line);
       std::cout << " ERROR: this mock object";
       if (state.first_used_test != "") {
-        std::cout << " (used in test " << state.first_used_test_suite << "."
-                  << state.first_used_test << ")";
+        std::cout << " (used in test " << state.first_used_test_suite << "." 
+                  << state.first_used_test << ")"; 
       }
       std::cout << " should be deleted but never is. Its address is @"
            << it->first << ".";
       leaked_count++;
     }
     if (leaked_count > 0) {
-      std::cout << "\nERROR: " << leaked_count << " leaked mock "
-                << (leaked_count == 1 ? "object" : "objects")
-                << " found at program exit. Expectations on a mock object are "
-                   "verified when the object is destructed. Leaking a mock "
-                   "means that its expectations aren't verified, which is "
-                   "usually a test bug. If you really intend to leak a mock, "
-                   "you can suppress this error using "
-                   "testing::Mock::AllowLeak(mock_object), or you may use a "
-                   "fake or stub instead of a mock.\n";
+      std::cout << "\nERROR: " << leaked_count << " leaked mock " 
+                << (leaked_count == 1 ? "object" : "objects") 
+                << " found at program exit. Expectations on a mock object are " 
+                   "verified when the object is destructed. Leaking a mock " 
+                   "means that its expectations aren't verified, which is " 
+                   "usually a test bug. If you really intend to leak a mock, " 
+                   "you can suppress this error using " 
+                   "testing::Mock::AllowLeak(mock_object), or you may use a " 
+                   "fake or stub instead of a mock.\n"; 
       std::cout.flush();
       ::std::cerr.flush();
       // RUN_ALL_TESTS() has already returned when this destructor is
@@ -717,8 +717,8 @@ internal::CallReaction Mock::GetReactionOnUninterestingCalls(
         GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   internal::MutexLock l(&internal::g_gmock_mutex);
   return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
-      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
-      g_uninteresting_call_reaction[mock_obj];
+      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) : 
+      g_uninteresting_call_reaction[mock_obj]; 
 }
 
 // Tells Google Mock to ignore mock_obj when checking for leaked mock
@@ -739,7 +739,7 @@ bool Mock::VerifyAndClearExpectations(void* mock_obj)
 }
 
 // Verifies all expectations on the given mock object and clears its
-// default actions and expectations.  Returns true if and only if the
+// default actions and expectations.  Returns true if and only if the 
 // verification was successful.
 bool Mock::VerifyAndClear(void* mock_obj)
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
@@ -776,19 +776,19 @@ bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
   return expectations_met;
 }
 
-bool Mock::IsNaggy(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn;
-}
-bool Mock::IsNice(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow;
-}
-bool Mock::IsStrict(void* mock_obj)
-    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail;
-}
-
+bool Mock::IsNaggy(void* mock_obj) 
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn; 
+} 
+bool Mock::IsNice(void* mock_obj) 
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow; 
+} 
+bool Mock::IsStrict(void* mock_obj) 
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) { 
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail; 
+} 
+ 
 // Registers a mock object and a mock method it owns.
 void Mock::Register(const void* mock_obj,
                     internal::UntypedFunctionMockerBase* mocker)
@@ -805,13 +805,13 @@ void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
     GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
   internal::MutexLock l(&internal::g_gmock_mutex);
   MockObjectState& state = g_mock_object_registry.states()[mock_obj];
-  if (state.first_used_file == nullptr) {
+  if (state.first_used_file == nullptr) { 
     state.first_used_file = file;
     state.first_used_line = line;
     const TestInfo* const test_info =
         UnitTest::GetInstance()->current_test_info();
-    if (test_info != nullptr) {
-      state.first_used_test_suite = test_info->test_suite_name();
+    if (test_info != nullptr) { 
+      state.first_used_test_suite = test_info->test_suite_name(); 
       state.first_used_test = test_info->name();
     }
   }
@@ -864,7 +864,7 @@ void Mock::ClearDefaultActionsLocked(void* mock_obj)
 Expectation::Expectation() {}
 
 Expectation::Expectation(
-    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
+    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base) 
     : expectation_base_(an_expectation_base) {}
 
 Expectation::~Expectation() {}
@@ -872,7 +872,7 @@ Expectation::~Expectation() {}
 // Adds an expectation to a sequence.
 void Sequence::AddExpectation(const Expectation& expectation) const {
   if (*last_expectation_ != expectation) {
-    if (last_expectation_->expectation_base() != nullptr) {
+    if (last_expectation_->expectation_base() != nullptr) { 
       expectation.expectation_base()->immediate_prerequisites_
           += *last_expectation_;
     }
@@ -882,7 +882,7 @@ void Sequence::AddExpectation(const Expectation& expectation) const {
 
 // Creates the implicit sequence if there isn't one.
 InSequence::InSequence() {
-  if (internal::g_gmock_implicit_sequence.get() == nullptr) {
+  if (internal::g_gmock_implicit_sequence.get() == nullptr) { 
     internal::g_gmock_implicit_sequence.set(new Sequence);
     sequence_created_ = true;
   } else {
@@ -895,14 +895,14 @@ InSequence::InSequence() {
 InSequence::~InSequence() {
   if (sequence_created_) {
     delete internal::g_gmock_implicit_sequence.get();
-    internal::g_gmock_implicit_sequence.set(nullptr);
+    internal::g_gmock_implicit_sequence.set(nullptr); 
   }
 }
 
 }  // namespace testing
-
-#ifdef _MSC_VER
-#if _MSC_VER == 1900
-#  pragma warning(pop)
-#endif
-#endif
+ 
+#ifdef _MSC_VER 
+#if _MSC_VER == 1900 
+#  pragma warning(pop) 
+#endif 
+#endif 
diff --git a/contrib/restricted/googletest/googlemock/src/gmock.cc b/contrib/restricted/googletest/googlemock/src/gmock.cc
index 7bcdb0ba2d..ee7a367d51 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock.cc
@@ -27,15 +27,15 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 #include "gmock/gmock.h"
 #include "gmock/internal/gmock-port.h"
 
 namespace testing {
 
 GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
-                   "true if and only if Google Mock should report leaked "
-                   "mock objects as failures.");
+                   "true if and only if Google Mock should report leaked " 
+                   "mock objects as failures."); 
 
 GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
                      "Controls how verbose Google Mock's output is."
@@ -44,13 +44,13 @@ GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
                      "  warning - prints warnings and errors.\n"
                      "  error   - prints errors only.");
 
-GMOCK_DEFINE_int32_(default_mock_behavior, 1,
-                    "Controls the default behavior of mocks."
-                    "  Valid values:\n"
-                    "  0 - by default, mocks act as NiceMocks.\n"
-                    "  1 - by default, mocks act as NaggyMocks.\n"
-                    "  2 - by default, mocks act as StrictMocks.");
-
+GMOCK_DEFINE_int32_(default_mock_behavior, 1, 
+                    "Controls the default behavior of mocks." 
+                    "  Valid values:\n" 
+                    "  0 - by default, mocks act as NiceMocks.\n" 
+                    "  1 - by default, mocks act as NaggyMocks.\n" 
+                    "  2 - by default, mocks act as StrictMocks."); 
+ 
 namespace internal {
 
 // Parses a string as a command line flag.  The string should have the
@@ -62,12 +62,12 @@ static const char* ParseGoogleMockFlagValue(const char* str,
                                             const char* flag,
                                             bool def_optional) {
   // str and flag must not be NULL.
-  if (str == nullptr || flag == nullptr) return nullptr;
+  if (str == nullptr || flag == nullptr) return nullptr; 
 
   // The flag must start with "--gmock_".
   const std::string flag_str = std::string("--gmock_") + flag;
   const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; 
 
   // Skips the flag name.
   const char* flag_end = str + flag_len;
@@ -80,7 +80,7 @@ static const char* ParseGoogleMockFlagValue(const char* str,
   // If def_optional is true and there are more characters after the
   // flag name, or if def_optional is false, there must be a '=' after
   // the flag name.
-  if (flag_end[0] != '=') return nullptr;
+  if (flag_end[0] != '=') return nullptr; 
 
   // Returns the string after "=".
   return flag_end + 1;
@@ -97,7 +97,7 @@ static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
   const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
 
   // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
+  if (value_str == nullptr) return false; 
 
   // Converts the string value to a bool.
   *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
@@ -116,26 +116,26 @@ static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
   const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
 
   // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
+  if (value_str == nullptr) return false; 
 
   // Sets *value to the value of the flag.
   *value = value_str;
   return true;
 }
 
-static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
-                                   int32_t* value) {
-  // Gets the value of the flag as a string.
-  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
-
-  // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
-
-  // Sets *value to the value of the flag.
-  return ParseInt32(Message() << "The value of flag --" << flag,
-                    value_str, value);
-}
-
+static bool ParseGoogleMockIntFlag(const char* str, const char* flag, 
+                                   int32_t* value) { 
+  // Gets the value of the flag as a string. 
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true); 
+ 
+  // Aborts if the parsing failed. 
+  if (value_str == nullptr) return false; 
+ 
+  // Sets *value to the value of the flag. 
+  return ParseInt32(Message() << "The value of flag --" << flag, 
+                    value_str, value); 
+} 
+ 
 // The internal implementation of InitGoogleMock().
 //
 // The type parameter CharType can be instantiated to either char or
@@ -154,9 +154,9 @@ void InitGoogleMockImpl(int* argc, CharType** argv) {
     // Do we see a Google Mock flag?
     if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
                                 &GMOCK_FLAG(catch_leaked_mocks)) ||
-        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
-        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
-                               &GMOCK_FLAG(default_mock_behavior))) {
+        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) || 
+        ParseGoogleMockIntFlag(arg, "default_mock_behavior", 
+                               &GMOCK_FLAG(default_mock_behavior))) { 
       // Yes.  Shift the remainder of the argv list left by one.  Note
       // that argv has (*argc + 1) elements, the last one always being
       // NULL.  The following loop moves the trailing NULL element as
@@ -198,16 +198,16 @@ GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
   internal::InitGoogleMockImpl(argc, argv);
 }
 
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-GTEST_API_ void InitGoogleMock() {
-  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
-  int argc = 1;
-  const auto arg0 = "dummy";
-  char* argv0 = const_cast<char*>(arg0);
-  char** argv = &argv0;
-
-  internal::InitGoogleMockImpl(&argc, argv);
-}
-
+// This overloaded version can be used on Arduino/embedded platforms where 
+// there is no argc/argv. 
+GTEST_API_ void InitGoogleMock() { 
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments 
+  int argc = 1; 
+  const auto arg0 = "dummy"; 
+  char* argv0 = const_cast<char*>(arg0); 
+  char** argv = &argv0; 
+ 
+  internal::InitGoogleMockImpl(&argc, argv); 
+} 
+ 
 }  // namespace testing
diff --git a/contrib/restricted/googletest/googlemock/src/gmock_main.cc b/contrib/restricted/googletest/googlemock/src/gmock_main.cc
index 18c500f663..87873bc372 100644
--- a/contrib/restricted/googletest/googlemock/src/gmock_main.cc
+++ b/contrib/restricted/googletest/googlemock/src/gmock_main.cc
@@ -27,34 +27,34 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 #include <iostream>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-#if GTEST_OS_ESP8266 || GTEST_OS_ESP32
-#if GTEST_OS_ESP8266
-extern "C" {
-#endif
-void setup() {
-  // Since Google Mock depends on Google Test, InitGoogleMock() is
-  // also responsible for initializing Google Test.  Therefore there's
-  // no need for calling testing::InitGoogleTest() separately.
-  testing::InitGoogleMock();
-}
-void loop() { RUN_ALL_TESTS(); }
-#if GTEST_OS_ESP8266
-}
-#endif
-
-#else
-
+#if GTEST_OS_ESP8266 || GTEST_OS_ESP32 
+#if GTEST_OS_ESP8266 
+extern "C" { 
+#endif 
+void setup() { 
+  // Since Google Mock depends on Google Test, InitGoogleMock() is 
+  // also responsible for initializing Google Test.  Therefore there's 
+  // no need for calling testing::InitGoogleTest() separately. 
+  testing::InitGoogleMock(); 
+} 
+void loop() { RUN_ALL_TESTS(); } 
+#if GTEST_OS_ESP8266 
+} 
+#endif 
+ 
+#else 
+ 
 // MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
 // causes a link error when _tmain is defined in a static library and UNICODE
 // is enabled. For this reason instead of _tmain, main function is used on
 // Windows. See the following link to track the current status of this bug:
-// https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library
-// // NOLINT
+// https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library 
+// // NOLINT 
 #if GTEST_OS_WINDOWS_MOBILE
 # include <tchar.h>  // NOLINT
 
@@ -69,4 +69,4 @@ GTEST_API_ int main(int argc, char** argv) {
   testing::InitGoogleMock(&argc, argv);
   return RUN_ALL_TESTS();
 }
-#endif
+#endif 
diff --git a/contrib/restricted/googletest/googlemock/ya.make b/contrib/restricted/googletest/googlemock/ya.make
index 38649ba5fc..223cd92e0c 100644
--- a/contrib/restricted/googletest/googlemock/ya.make
+++ b/contrib/restricted/googletest/googlemock/ya.make
@@ -11,18 +11,18 @@ LICENSE(
     Apache-2.0 AND
     BSD-3-Clause
 )
-
+ 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/restricted/googletest/googletest
+    contrib/restricted/googletest/googletest 
 )
 
 ADDINCL(
-    GLOBAL contrib/restricted/googletest/googlemock/include
-    GLOBAL contrib/restricted/googletest/googletest/include
-    contrib/restricted/googletest/googlemock
-    contrib/restricted/googletest/googletest
+    GLOBAL contrib/restricted/googletest/googlemock/include 
+    GLOBAL contrib/restricted/googletest/googletest/include 
+    contrib/restricted/googletest/googlemock 
+    contrib/restricted/googletest/googletest 
 )
 
 NO_COMPILER_WARNINGS()
@@ -36,7 +36,7 @@ CFLAGS(
 )
 
 SRCS(
-    src/gmock-all.cc
+    src/gmock-all.cc 
 )
 
 END()
diff --git a/contrib/restricted/googletest/googletest/README.md b/contrib/restricted/googletest/googletest/README.md
index 1f8b349ae7..056828d256 100644
--- a/contrib/restricted/googletest/googletest/README.md
+++ b/contrib/restricted/googletest/googletest/README.md
@@ -1,215 +1,215 @@
-### Generic Build Instructions
-
-#### Setup
-
-To build GoogleTest and your tests that use it, you need to tell your build
-system where to find its headers and source files. The exact way to do it
-depends on which build system you use, and is usually straightforward.
-
-### Build with CMake
-
-GoogleTest comes with a CMake build script
-([CMakeLists.txt](https://github.com/google/googletest/blob/master/CMakeLists.txt))
-that can be used on a wide range of platforms ("C" stands for cross-platform.).
-If you don't have CMake installed already, you can download it for free from
-<http://www.cmake.org/>.
-
-CMake works by generating native makefiles or build projects that can be used in
-the compiler environment of your choice. You can either build GoogleTest as a
-standalone project or it can be incorporated into an existing CMake build for
-another project.
-
-#### Standalone CMake Project
-
-When building GoogleTest as a standalone project, the typical workflow starts
-with
-
-```
-git clone https://github.com/google/googletest.git -b release-1.10.0
-cd googletest        # Main directory of the cloned repository.
-mkdir build          # Create a directory to hold the build output.
-cd build
-cmake ..             # Generate native build scripts for GoogleTest.
-```
-
-The above command also includes GoogleMock by default. And so, if you want to
-build only GoogleTest, you should replace the last command with
-
-```
-cmake .. -DBUILD_GMOCK=OFF
-```
-
-If you are on a \*nix system, you should now see a Makefile in the current
-directory. Just type `make` to build GoogleTest. And then you can simply install
-GoogleTest if you are a system administrator.
-
-```
-make
-sudo make install    # Install in /usr/local/ by default
-```
-
-If you use Windows and have Visual Studio installed, a `gtest.sln` file and
-several `.vcproj` files will be created. You can then build them using Visual
-Studio.
-
-On Mac OS X with Xcode installed, a `.xcodeproj` file will be generated.
-
-#### Incorporating Into An Existing CMake Project
-
-If you want to use GoogleTest in a project which already uses CMake, the easiest
-way is to get installed libraries and headers.
-
-*   Import GoogleTest by using `find_package` (or `pkg_check_modules`). For
-    example, if `find_package(GTest CONFIG REQUIRED)` succeeds, you can use the
-    libraries as `GTest::gtest`, `GTest::gmock`.
-
-And a more robust and flexible approach is to build GoogleTest as part of that
-project directly. This is done by making the GoogleTest source code available to
-the main build and adding it using CMake's `add_subdirectory()` command. This
-has the significant advantage that the same compiler and linker settings are
-used between GoogleTest and the rest of your project, so issues associated with
-using incompatible libraries (eg debug/release), etc. are avoided. This is
-particularly useful on Windows. Making GoogleTest's source code available to the
-main build can be done a few different ways:
-
-*   Download the GoogleTest source code manually and place it at a known
-    location. This is the least flexible approach and can make it more difficult
-    to use with continuous integration systems, etc.
-*   Embed the GoogleTest source code as a direct copy in the main project's
-    source tree. This is often the simplest approach, but is also the hardest to
-    keep up to date. Some organizations may not permit this method.
-*   Add GoogleTest as a git submodule or equivalent. This may not always be
-    possible or appropriate. Git submodules, for example, have their own set of
-    advantages and drawbacks.
-*   Use CMake to download GoogleTest as part of the build's configure step. This
-    approach doesn't have the limitations of the other methods.
-
-The last of the above methods is implemented with a small piece of CMake code
-that downloads and pulls the GoogleTest code into the main build.
-
-Just add to your `CMakeLists.txt`:
-
-```cmake
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  # Specify the commit you depend on and update it regularly.
-  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
-)
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
-
-# Now simply link against gtest or gtest_main as needed. Eg
-add_executable(example example.cpp)
-target_link_libraries(example gtest_main)
-add_test(NAME example_test COMMAND example)
-```
-
-Note that this approach requires CMake 3.14 or later due to its use of the
-`FetchContent_MakeAvailable()` command.
-
-##### Visual Studio Dynamic vs Static Runtimes
-
-By default, new Visual Studio projects link the C runtimes dynamically but
-GoogleTest links them statically. This will generate an error that looks
-something like the following: gtest.lib(gtest-all.obj) : error LNK2038: mismatch
-detected for 'RuntimeLibrary': value 'MTd_StaticDebug' doesn't match value
-'MDd_DynamicDebug' in main.obj
-
-GoogleTest already has a CMake option for this: `gtest_force_shared_crt`
-
-Enabling this option will make gtest link the runtimes dynamically too, and
-match the project in which it is included.
-
-#### C++ Standard Version
-
-An environment that supports C++11 is required in order to successfully build
-GoogleTest. One way to ensure this is to specify the standard in the top-level
-project, for example by using the `set(CMAKE_CXX_STANDARD 11)` command. If this
-is not feasible, for example in a C project using GoogleTest for validation,
-then it can be specified by adding it to the options for cmake via the
-`DCMAKE_CXX_FLAGS` option.
-
-### Tweaking GoogleTest
-
-GoogleTest can be used in diverse environments. The default configuration may
-not work (or may not work well) out of the box in some environments. However,
-you can easily tweak GoogleTest by defining control macros on the compiler
-command line. Generally, these macros are named like `GTEST_XYZ` and you define
-them to either 1 or 0 to enable or disable a certain feature.
-
-We list the most frequently used macros below. For a complete list, see file
-[include/gtest/internal/gtest-port.h](https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-port.h).
-
-### Multi-threaded Tests
-
-GoogleTest is thread-safe where the pthread library is available. After
-`#include "gtest/gtest.h"`, you can check the
-`GTEST_IS_THREADSAFE` macro to see whether this is the case (yes if the macro is
-`#defined` to 1, no if it's undefined.).
-
-If GoogleTest doesn't correctly detect whether pthread is available in your
-environment, you can force it with
-
-    -DGTEST_HAS_PTHREAD=1
-
-or
-
-    -DGTEST_HAS_PTHREAD=0
-
-When GoogleTest uses pthread, you may need to add flags to your compiler and/or
-linker to select the pthread library, or you'll get link errors. If you use the
-CMake script, this is taken care of for you. If you use your own build script,
-you'll need to read your compiler and linker's manual to figure out what flags
-to add.
-
-### As a Shared Library (DLL)
-
-GoogleTest is compact, so most users can build and link it as a static library
-for the simplicity. You can choose to use GoogleTest as a shared library (known
-as a DLL on Windows) if you prefer.
-
-To compile *gtest* as a shared library, add
-
-    -DGTEST_CREATE_SHARED_LIBRARY=1
-
-to the compiler flags. You'll also need to tell the linker to produce a shared
-library instead - consult your linker's manual for how to do it.
-
-To compile your *tests* that use the gtest shared library, add
-
-    -DGTEST_LINKED_AS_SHARED_LIBRARY=1
-
-to the compiler flags.
-
-Note: while the above steps aren't technically necessary today when using some
-compilers (e.g. GCC), they may become necessary in the future, if we decide to
-improve the speed of loading the library (see
-<http://gcc.gnu.org/wiki/Visibility> for details). Therefore you are recommended
-to always add the above flags when using GoogleTest as a shared library.
-Otherwise a future release of GoogleTest may break your build script.
-
-### Avoiding Macro Name Clashes
-
-In C++, macros don't obey namespaces. Therefore two libraries that both define a
-macro of the same name will clash if you `#include` both definitions. In case a
-GoogleTest macro clashes with another library, you can force GoogleTest to
-rename its macro to avoid the conflict.
-
-Specifically, if both GoogleTest and some other code define macro FOO, you can
-add
-
-    -DGTEST_DONT_DEFINE_FOO=1
-
-to the compiler flags to tell GoogleTest to change the macro's name from `FOO`
-to `GTEST_FOO`. Currently `FOO` can be `FAIL`, `SUCCEED`, or `TEST`. For
-example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write
-
-    GTEST_TEST(SomeTest, DoesThis) { ... }
-
-instead of
-
-    TEST(SomeTest, DoesThis) { ... }
-
-in order to define a test.
+### Generic Build Instructions 
+ 
+#### Setup 
+ 
+To build GoogleTest and your tests that use it, you need to tell your build 
+system where to find its headers and source files. The exact way to do it 
+depends on which build system you use, and is usually straightforward. 
+ 
+### Build with CMake 
+ 
+GoogleTest comes with a CMake build script 
+([CMakeLists.txt](https://github.com/google/googletest/blob/master/CMakeLists.txt)) 
+that can be used on a wide range of platforms ("C" stands for cross-platform.). 
+If you don't have CMake installed already, you can download it for free from 
+<http://www.cmake.org/>. 
+ 
+CMake works by generating native makefiles or build projects that can be used in 
+the compiler environment of your choice. You can either build GoogleTest as a 
+standalone project or it can be incorporated into an existing CMake build for 
+another project. 
+ 
+#### Standalone CMake Project 
+ 
+When building GoogleTest as a standalone project, the typical workflow starts 
+with 
+ 
+``` 
+git clone https://github.com/google/googletest.git -b release-1.10.0 
+cd googletest        # Main directory of the cloned repository. 
+mkdir build          # Create a directory to hold the build output. 
+cd build 
+cmake ..             # Generate native build scripts for GoogleTest. 
+``` 
+ 
+The above command also includes GoogleMock by default. And so, if you want to 
+build only GoogleTest, you should replace the last command with 
+ 
+``` 
+cmake .. -DBUILD_GMOCK=OFF 
+``` 
+ 
+If you are on a \*nix system, you should now see a Makefile in the current 
+directory. Just type `make` to build GoogleTest. And then you can simply install 
+GoogleTest if you are a system administrator. 
+ 
+``` 
+make 
+sudo make install    # Install in /usr/local/ by default 
+``` 
+ 
+If you use Windows and have Visual Studio installed, a `gtest.sln` file and 
+several `.vcproj` files will be created. You can then build them using Visual 
+Studio. 
+ 
+On Mac OS X with Xcode installed, a `.xcodeproj` file will be generated. 
+ 
+#### Incorporating Into An Existing CMake Project 
+ 
+If you want to use GoogleTest in a project which already uses CMake, the easiest 
+way is to get installed libraries and headers. 
+ 
+*   Import GoogleTest by using `find_package` (or `pkg_check_modules`). For 
+    example, if `find_package(GTest CONFIG REQUIRED)` succeeds, you can use the 
+    libraries as `GTest::gtest`, `GTest::gmock`. 
+ 
+And a more robust and flexible approach is to build GoogleTest as part of that 
+project directly. This is done by making the GoogleTest source code available to 
+the main build and adding it using CMake's `add_subdirectory()` command. This 
+has the significant advantage that the same compiler and linker settings are 
+used between GoogleTest and the rest of your project, so issues associated with 
+using incompatible libraries (eg debug/release), etc. are avoided. This is 
+particularly useful on Windows. Making GoogleTest's source code available to the 
+main build can be done a few different ways: 
+ 
+*   Download the GoogleTest source code manually and place it at a known 
+    location. This is the least flexible approach and can make it more difficult 
+    to use with continuous integration systems, etc. 
+*   Embed the GoogleTest source code as a direct copy in the main project's 
+    source tree. This is often the simplest approach, but is also the hardest to 
+    keep up to date. Some organizations may not permit this method. 
+*   Add GoogleTest as a git submodule or equivalent. This may not always be 
+    possible or appropriate. Git submodules, for example, have their own set of 
+    advantages and drawbacks. 
+*   Use CMake to download GoogleTest as part of the build's configure step. This 
+    approach doesn't have the limitations of the other methods. 
+ 
+The last of the above methods is implemented with a small piece of CMake code 
+that downloads and pulls the GoogleTest code into the main build. 
+ 
+Just add to your `CMakeLists.txt`: 
+ 
+```cmake 
+include(FetchContent) 
+FetchContent_Declare( 
+  googletest 
+  # Specify the commit you depend on and update it regularly. 
+  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip 
+) 
+# For Windows: Prevent overriding the parent project's compiler/linker settings 
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) 
+FetchContent_MakeAvailable(googletest) 
+ 
+# Now simply link against gtest or gtest_main as needed. Eg 
+add_executable(example example.cpp) 
+target_link_libraries(example gtest_main) 
+add_test(NAME example_test COMMAND example) 
+``` 
+ 
+Note that this approach requires CMake 3.14 or later due to its use of the 
+`FetchContent_MakeAvailable()` command. 
+ 
+##### Visual Studio Dynamic vs Static Runtimes 
+ 
+By default, new Visual Studio projects link the C runtimes dynamically but 
+GoogleTest links them statically. This will generate an error that looks 
+something like the following: gtest.lib(gtest-all.obj) : error LNK2038: mismatch 
+detected for 'RuntimeLibrary': value 'MTd_StaticDebug' doesn't match value 
+'MDd_DynamicDebug' in main.obj 
+ 
+GoogleTest already has a CMake option for this: `gtest_force_shared_crt` 
+ 
+Enabling this option will make gtest link the runtimes dynamically too, and 
+match the project in which it is included. 
+ 
+#### C++ Standard Version 
+ 
+An environment that supports C++11 is required in order to successfully build 
+GoogleTest. One way to ensure this is to specify the standard in the top-level 
+project, for example by using the `set(CMAKE_CXX_STANDARD 11)` command. If this 
+is not feasible, for example in a C project using GoogleTest for validation, 
+then it can be specified by adding it to the options for cmake via the 
+`DCMAKE_CXX_FLAGS` option. 
+ 
+### Tweaking GoogleTest 
+ 
+GoogleTest can be used in diverse environments. The default configuration may 
+not work (or may not work well) out of the box in some environments. However, 
+you can easily tweak GoogleTest by defining control macros on the compiler 
+command line. Generally, these macros are named like `GTEST_XYZ` and you define 
+them to either 1 or 0 to enable or disable a certain feature. 
+ 
+We list the most frequently used macros below. For a complete list, see file 
+[include/gtest/internal/gtest-port.h](https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-port.h). 
+ 
+### Multi-threaded Tests 
+ 
+GoogleTest is thread-safe where the pthread library is available. After 
+`#include "gtest/gtest.h"`, you can check the 
+`GTEST_IS_THREADSAFE` macro to see whether this is the case (yes if the macro is 
+`#defined` to 1, no if it's undefined.). 
+ 
+If GoogleTest doesn't correctly detect whether pthread is available in your 
+environment, you can force it with 
+ 
+    -DGTEST_HAS_PTHREAD=1 
+ 
+or 
+ 
+    -DGTEST_HAS_PTHREAD=0 
+ 
+When GoogleTest uses pthread, you may need to add flags to your compiler and/or 
+linker to select the pthread library, or you'll get link errors. If you use the 
+CMake script, this is taken care of for you. If you use your own build script, 
+you'll need to read your compiler and linker's manual to figure out what flags 
+to add. 
+ 
+### As a Shared Library (DLL) 
+ 
+GoogleTest is compact, so most users can build and link it as a static library 
+for the simplicity. You can choose to use GoogleTest as a shared library (known 
+as a DLL on Windows) if you prefer. 
+ 
+To compile *gtest* as a shared library, add 
+ 
+    -DGTEST_CREATE_SHARED_LIBRARY=1 
+ 
+to the compiler flags. You'll also need to tell the linker to produce a shared 
+library instead - consult your linker's manual for how to do it. 
+ 
+To compile your *tests* that use the gtest shared library, add 
+ 
+    -DGTEST_LINKED_AS_SHARED_LIBRARY=1 
+ 
+to the compiler flags. 
+ 
+Note: while the above steps aren't technically necessary today when using some 
+compilers (e.g. GCC), they may become necessary in the future, if we decide to 
+improve the speed of loading the library (see 
+<http://gcc.gnu.org/wiki/Visibility> for details). Therefore you are recommended 
+to always add the above flags when using GoogleTest as a shared library. 
+Otherwise a future release of GoogleTest may break your build script. 
+ 
+### Avoiding Macro Name Clashes 
+ 
+In C++, macros don't obey namespaces. Therefore two libraries that both define a 
+macro of the same name will clash if you `#include` both definitions. In case a 
+GoogleTest macro clashes with another library, you can force GoogleTest to 
+rename its macro to avoid the conflict. 
+ 
+Specifically, if both GoogleTest and some other code define macro FOO, you can 
+add 
+ 
+    -DGTEST_DONT_DEFINE_FOO=1 
+ 
+to the compiler flags to tell GoogleTest to change the macro's name from `FOO` 
+to `GTEST_FOO`. Currently `FOO` can be `FAIL`, `SUCCEED`, or `TEST`. For 
+example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write 
+ 
+    GTEST_TEST(SomeTest, DoesThis) { ... } 
+ 
+instead of 
+ 
+    TEST(SomeTest, DoesThis) { ... } 
+ 
+in order to define a test. 
diff --git a/contrib/restricted/googletest/googletest/gtest_main/ya.make b/contrib/restricted/googletest/googletest/gtest_main/ya.make
index 98edf7262a..444c91c6d8 100644
--- a/contrib/restricted/googletest/googletest/gtest_main/ya.make
+++ b/contrib/restricted/googletest/googletest/gtest_main/ya.make
@@ -12,14 +12,14 @@ LICENSE(BSD-3-Clause)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/restricted/googletest/googletest
-)
-
-ADDINCL(
-    GLOBAL contrib/restricted/googletest/googletest/include
-    contrib/restricted/googletest/googletest
+    contrib/restricted/googletest/googletest 
 )
 
+ADDINCL( 
+    GLOBAL contrib/restricted/googletest/googletest/include 
+    contrib/restricted/googletest/googletest 
+) 
+ 
 NO_COMPILER_WARNINGS()
 
 NO_UTIL()
@@ -30,7 +30,7 @@ CFLAGS(
     GLOBAL -DGTEST_HAS_STD_WSTRING=1
 )
 
-SRCDIR(contrib/restricted/googletest/googletest/src)
+SRCDIR(contrib/restricted/googletest/googletest/src) 
 
 SRCS(
     GLOBAL gtest_main.cc
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-death-test.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-death-test.h
index 9b4d4d1337..3cfe2fe17f 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-death-test.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-death-test.h
@@ -26,17 +26,17 @@
 // 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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file defines the public API for death tests.  It is
 // #included by gtest.h so a user doesn't need to include this
 // directly.
-// GOOGLETEST_CM0001 DO NOT DELETE
+// GOOGLETEST_CM0001 DO NOT DELETE 
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ 
 
 #include "gtest/internal/gtest-death-test-internal.h"
 
@@ -97,17 +97,17 @@ GTEST_API_ bool InDeathTestChild();
 //
 //   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
 //
-// The final parameter to each of these macros is a matcher applied to any data
-// the sub-process wrote to stderr.  For compatibility with existing tests, a
-// bare string is interpreted as a regular expression matcher.
-//
+// The final parameter to each of these macros is a matcher applied to any data 
+// the sub-process wrote to stderr.  For compatibility with existing tests, a 
+// bare string is interpreted as a regular expression matcher. 
+// 
 // On the regular expressions used in death tests:
 //
-//   GOOGLETEST_CM0005 DO NOT DELETE
+//   GOOGLETEST_CM0005 DO NOT DELETE 
 //   On POSIX-compliant systems (*nix), we use the <regex.h> library,
 //   which uses the POSIX extended regex syntax.
 //
-//   On other platforms (e.g. Windows or Mac), we only support a simple regex
+//   On other platforms (e.g. Windows or Mac), we only support a simple regex 
 //   syntax implemented as part of Google Test.  This limited
 //   implementation should be enough most of the time when writing
 //   death tests; though it lacks many features you can find in PCRE
@@ -166,27 +166,27 @@ GTEST_API_ bool InDeathTestChild();
 //   directory in PATH.
 //
 
-// Asserts that a given `statement` causes the program to exit, with an
-// integer exit status that satisfies `predicate`, and emitting error output
-// that matches `matcher`.
-# define ASSERT_EXIT(statement, predicate, matcher) \
-    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_)
+// Asserts that a given `statement` causes the program to exit, with an 
+// integer exit status that satisfies `predicate`, and emitting error output 
+// that matches `matcher`. 
+# define ASSERT_EXIT(statement, predicate, matcher) \ 
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_) 
 
-// Like `ASSERT_EXIT`, but continues on to successive tests in the
-// test suite, if any:
-# define EXPECT_EXIT(statement, predicate, matcher) \
-    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_)
+// Like `ASSERT_EXIT`, but continues on to successive tests in the 
+// test suite, if any: 
+# define EXPECT_EXIT(statement, predicate, matcher) \ 
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_) 
 
-// Asserts that a given `statement` causes the program to exit, either by
+// Asserts that a given `statement` causes the program to exit, either by 
 // explicitly exiting with a nonzero exit code or being killed by a
-// signal, and emitting error output that matches `matcher`.
-# define ASSERT_DEATH(statement, matcher) \
-    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+// signal, and emitting error output that matches `matcher`. 
+# define ASSERT_DEATH(statement, matcher) \ 
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) 
 
-// Like `ASSERT_DEATH`, but continues on to successive tests in the
-// test suite, if any:
-# define EXPECT_DEATH(statement, matcher) \
-    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+// Like `ASSERT_DEATH`, but continues on to successive tests in the 
+// test suite, if any: 
+# define EXPECT_DEATH(statement, matcher) \ 
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) 
 
 // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
 
@@ -194,17 +194,17 @@ GTEST_API_ bool InDeathTestChild();
 class GTEST_API_ ExitedWithCode {
  public:
   explicit ExitedWithCode(int exit_code);
-  ExitedWithCode(const ExitedWithCode&) = default;
-  void operator=(const ExitedWithCode& other) = delete;
+  ExitedWithCode(const ExitedWithCode&) = default; 
+  void operator=(const ExitedWithCode& other) = delete; 
   bool operator()(int exit_status) const;
  private:
   const int exit_code_;
 };
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 // Tests that an exit code describes an exit due to termination by a
 // given signal.
-// GOOGLETEST_CM0006 DO NOT DELETE
+// GOOGLETEST_CM0006 DO NOT DELETE 
 class GTEST_API_ KilledBySignal {
  public:
   explicit KilledBySignal(int signum);
@@ -230,7 +230,7 @@ class GTEST_API_ KilledBySignal {
 //   return 12;
 // }
 //
-// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
+// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) { 
 //   int sideeffect = 0;
 //   // Only asserts in dbg.
 //   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
@@ -276,54 +276,54 @@ class GTEST_API_ KilledBySignal {
 # endif  // NDEBUG for EXPECT_DEBUG_DEATH
 #endif  // GTEST_HAS_DEATH_TEST
 
-// This macro is used for implementing macros such as
-// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
-// death tests are not supported. Those macros must compile on such systems
-// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters
-// on systems that support death tests. This allows one to write such a macro on
-// a system that does not support death tests and be sure that it will compile
-// on a death-test supporting system. It is exposed publicly so that systems
-// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST
-// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
-// ASSERT_DEATH_IF_SUPPORTED.
-//
-// Parameters:
-//   statement -  A statement that a macro such as EXPECT_DEATH would test
-//                for program termination. This macro has to make sure this
-//                statement is compiled but not executed, to ensure that
-//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
-//                parameter if and only if EXPECT_DEATH compiles with it.
-//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
-//                the output of statement.  This parameter has to be
-//                compiled but not evaluated by this macro, to ensure that
-//                this macro only accepts expressions that a macro such as
-//                EXPECT_DEATH would accept.
-//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
-//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
-//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
-//                compile inside functions where ASSERT_DEATH doesn't
-//                compile.
-//
-//  The branch that has an always false condition is used to ensure that
-//  statement and regex are compiled (and thus syntactically correct) but
-//  never executed. The unreachable code macro protects the terminator
-//  statement from generating an 'unreachable code' warning in case
-//  statement unconditionally returns or throws. The Message constructor at
-//  the end allows the syntax of streaming additional messages into the
-//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
-    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-    if (::testing::internal::AlwaysTrue()) { \
-      GTEST_LOG_(WARNING) \
-          << "Death tests are not supported on this platform.\n" \
-          << "Statement '" #statement "' cannot be verified."; \
-    } else if (::testing::internal::AlwaysFalse()) { \
-      ::testing::internal::RE::PartialMatch(".*", (regex)); \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
-      terminator; \
-    } else \
-      ::testing::Message()
-
+// This macro is used for implementing macros such as 
+// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where 
+// death tests are not supported. Those macros must compile on such systems 
+// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters 
+// on systems that support death tests. This allows one to write such a macro on 
+// a system that does not support death tests and be sure that it will compile 
+// on a death-test supporting system. It is exposed publicly so that systems 
+// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST 
+// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and 
+// ASSERT_DEATH_IF_SUPPORTED. 
+// 
+// Parameters: 
+//   statement -  A statement that a macro such as EXPECT_DEATH would test 
+//                for program termination. This macro has to make sure this 
+//                statement is compiled but not executed, to ensure that 
+//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain 
+//                parameter if and only if EXPECT_DEATH compiles with it. 
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test 
+//                the output of statement.  This parameter has to be 
+//                compiled but not evaluated by this macro, to ensure that 
+//                this macro only accepts expressions that a macro such as 
+//                EXPECT_DEATH would accept. 
+//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED 
+//                and a return statement for ASSERT_DEATH_IF_SUPPORTED. 
+//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not 
+//                compile inside functions where ASSERT_DEATH doesn't 
+//                compile. 
+// 
+//  The branch that has an always false condition is used to ensure that 
+//  statement and regex are compiled (and thus syntactically correct) but 
+//  never executed. The unreachable code macro protects the terminator 
+//  statement from generating an 'unreachable code' warning in case 
+//  statement unconditionally returns or throws. The Message constructor at 
+//  the end allows the syntax of streaming additional messages into the 
+//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. 
+# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \ 
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 
+    if (::testing::internal::AlwaysTrue()) { \ 
+      GTEST_LOG_(WARNING) \ 
+          << "Death tests are not supported on this platform.\n" \ 
+          << "Statement '" #statement "' cannot be verified."; \ 
+    } else if (::testing::internal::AlwaysFalse()) { \ 
+      ::testing::internal::RE::PartialMatch(".*", (regex)); \ 
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ 
+      terminator; \ 
+    } else \ 
+      ::testing::Message() 
+ 
 // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
 // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
 // death tests are supported; otherwise they just issue a warning.  This is
@@ -336,11 +336,11 @@ class GTEST_API_ KilledBySignal {
     ASSERT_DEATH(statement, regex)
 #else
 # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, ) 
 # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
-    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return) 
 #endif
 
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-matchers.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-matchers.h
index 942cd2475c..b3e2cb669c 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-matchers.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-matchers.h
@@ -1,932 +1,932 @@
-// Copyright 2007, 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 file implements just enough of the matcher interface to allow
-// EXPECT_DEATH and friends to accept a matcher argument.
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
-
-#include <atomic>
-#include <memory>
-#include <ostream>
-#include <string>
-#include <type_traits>
-
-#include "gtest/gtest-printers.h"
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-port.h"
-
-// MSVC warning C5046 is new as of VS2017 version 15.8.
-#if defined(_MSC_VER) && _MSC_VER >= 1915
-#define GTEST_MAYBE_5046_ 5046
-#else
-#define GTEST_MAYBE_5046_
-#endif
-
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(
-    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
-                              clients of class B */
-    /* Symbol involving type with internal linkage not defined */)
-
-namespace testing {
-
-// To implement a matcher Foo for type T, define:
-//   1. a class FooMatcherMatcher that implements the matcher interface:
-//     using is_gtest_matcher = void;
-//     bool MatchAndExplain(const T&, std::ostream*);
-//       (MatchResultListener* can also be used instead of std::ostream*)
-//     void DescribeTo(std::ostream*);
-//     void DescribeNegationTo(std::ostream*);
-//
-//   2. a factory function that creates a Matcher<T> object from a
-//      FooMatcherMatcher.
-
-class MatchResultListener {
- public:
-  // Creates a listener object with the given underlying ostream.  The
-  // listener does not own the ostream, and does not dereference it
-  // in the constructor or destructor.
-  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
-  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
-
-  // Streams x to the underlying ostream; does nothing if the ostream
-  // is NULL.
-  template <typename T>
-  MatchResultListener& operator<<(const T& x) {
-    if (stream_ != nullptr) *stream_ << x;
-    return *this;
-  }
-
-  // Returns the underlying ostream.
-  ::std::ostream* stream() { return stream_; }
-
-  // Returns true if and only if the listener is interested in an explanation
-  // of the match result.  A matcher's MatchAndExplain() method can use
-  // this information to avoid generating the explanation when no one
-  // intends to hear it.
-  bool IsInterested() const { return stream_ != nullptr; }
-
- private:
-  ::std::ostream* const stream_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
-};
-
-inline MatchResultListener::~MatchResultListener() {
-}
-
-// An instance of a subclass of this knows how to describe itself as a
-// matcher.
-class GTEST_API_ MatcherDescriberInterface {
- public:
-  virtual ~MatcherDescriberInterface() {}
-
-  // Describes this matcher to an ostream.  The function should print
-  // a verb phrase that describes the property a value matching this
-  // matcher should have.  The subject of the verb phrase is the value
-  // being matched.  For example, the DescribeTo() method of the Gt(7)
-  // matcher prints "is greater than 7".
-  virtual void DescribeTo(::std::ostream* os) const = 0;
-
-  // Describes the negation of this matcher to an ostream.  For
-  // example, if the description of this matcher is "is greater than
-  // 7", the negated description could be "is not greater than 7".
-  // You are not required to override this when implementing
-  // MatcherInterface, but it is highly advised so that your matcher
-  // can produce good error messages.
-  virtual void DescribeNegationTo(::std::ostream* os) const {
-    *os << "not (";
-    DescribeTo(os);
-    *os << ")";
-  }
-};
-
-// The implementation of a matcher.
-template <typename T>
-class MatcherInterface : public MatcherDescriberInterface {
- public:
-  // Returns true if and only if the matcher matches x; also explains the
-  // match result to 'listener' if necessary (see the next paragraph), in
-  // the form of a non-restrictive relative clause ("which ...",
-  // "whose ...", etc) that describes x.  For example, the
-  // MatchAndExplain() method of the Pointee(...) matcher should
-  // generate an explanation like "which points to ...".
-  //
-  // Implementations of MatchAndExplain() should add an explanation of
-  // the match result *if and only if* they can provide additional
-  // information that's not already present (or not obvious) in the
-  // print-out of x and the matcher's description.  Whether the match
-  // succeeds is not a factor in deciding whether an explanation is
-  // needed, as sometimes the caller needs to print a failure message
-  // when the match succeeds (e.g. when the matcher is used inside
-  // Not()).
-  //
-  // For example, a "has at least 10 elements" matcher should explain
-  // what the actual element count is, regardless of the match result,
-  // as it is useful information to the reader; on the other hand, an
-  // "is empty" matcher probably only needs to explain what the actual
-  // size is when the match fails, as it's redundant to say that the
-  // size is 0 when the value is already known to be empty.
-  //
-  // You should override this method when defining a new matcher.
-  //
-  // It's the responsibility of the caller (Google Test) to guarantee
-  // that 'listener' is not NULL.  This helps to simplify a matcher's
-  // implementation when it doesn't care about the performance, as it
-  // can talk to 'listener' without checking its validity first.
-  // However, in order to implement dummy listeners efficiently,
-  // listener->stream() may be NULL.
-  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
-
-  // Inherits these methods from MatcherDescriberInterface:
-  //   virtual void DescribeTo(::std::ostream* os) const = 0;
-  //   virtual void DescribeNegationTo(::std::ostream* os) const;
-};
-
-namespace internal {
-
-struct AnyEq {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a == b; }
-};
-struct AnyNe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a != b; }
-};
-struct AnyLt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a < b; }
-};
-struct AnyGt {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a > b; }
-};
-struct AnyLe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a <= b; }
-};
-struct AnyGe {
-  template <typename A, typename B>
-  bool operator()(const A& a, const B& b) const { return a >= b; }
-};
-
-// A match result listener that ignores the explanation.
-class DummyMatchResultListener : public MatchResultListener {
- public:
-  DummyMatchResultListener() : MatchResultListener(nullptr) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
-};
-
-// A match result listener that forwards the explanation to a given
-// ostream.  The difference between this and MatchResultListener is
-// that the former is concrete.
-class StreamMatchResultListener : public MatchResultListener {
- public:
-  explicit StreamMatchResultListener(::std::ostream* os)
-      : MatchResultListener(os) {}
-
- private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
-};
-
-struct SharedPayloadBase {
-  std::atomic<int> ref{1};
-  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); }
-  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; }
-};
-
-template <typename T>
-struct SharedPayload : SharedPayloadBase {
-  explicit SharedPayload(const T& v) : value(v) {}
-  explicit SharedPayload(T&& v) : value(std::move(v)) {}
-
-  static void Destroy(SharedPayloadBase* shared) {
-    delete static_cast<SharedPayload*>(shared);
-  }
-
-  T value;
-};
-
-// An internal class for implementing Matcher<T>, which will derive
-// from it.  We put functionalities common to all Matcher<T>
-// specializations here to avoid code duplication.
-template <typename T>
-class MatcherBase : private MatcherDescriberInterface {
- public:
-  // Returns true if and only if the matcher matches x; also explains the
-  // match result to 'listener'.
-  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
-    GTEST_CHECK_(vtable_ != nullptr);
-    return vtable_->match_and_explain(*this, x, listener);
-  }
-
-  // Returns true if and only if this matcher matches x.
-  bool Matches(const T& x) const {
-    DummyMatchResultListener dummy;
-    return MatchAndExplain(x, &dummy);
-  }
-
-  // Describes this matcher to an ostream.
-  void DescribeTo(::std::ostream* os) const final {
-    GTEST_CHECK_(vtable_ != nullptr);
-    vtable_->describe(*this, os, false);
-  }
-
-  // Describes the negation of this matcher to an ostream.
-  void DescribeNegationTo(::std::ostream* os) const final {
-    GTEST_CHECK_(vtable_ != nullptr);
-    vtable_->describe(*this, os, true);
-  }
-
-  // Explains why x matches, or doesn't match, the matcher.
-  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
-    StreamMatchResultListener listener(os);
-    MatchAndExplain(x, &listener);
-  }
-
-  // Returns the describer for this matcher object; retains ownership
-  // of the describer, which is only guaranteed to be alive when
-  // this matcher object is alive.
-  const MatcherDescriberInterface* GetDescriber() const {
-    if (vtable_ == nullptr) return nullptr;
-    return vtable_->get_describer(*this);
-  }
-
- protected:
-  MatcherBase() : vtable_(nullptr) {}
-
-  // Constructs a matcher from its implementation.
-  template <typename U>
-  explicit MatcherBase(const MatcherInterface<U>* impl) {
-    Init(impl);
-  }
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  MatcherBase(M&& m) {  // NOLINT
-    Init(std::forward<M>(m));
-  }
-
-  MatcherBase(const MatcherBase& other)
-      : vtable_(other.vtable_), buffer_(other.buffer_) {
-    if (IsShared()) buffer_.shared->Ref();
-  }
-
-  MatcherBase& operator=(const MatcherBase& other) {
-    if (this == &other) return *this;
-    Destroy();
-    vtable_ = other.vtable_;
-    buffer_ = other.buffer_;
-    if (IsShared()) buffer_.shared->Ref();
-    return *this;
-  }
-
-  MatcherBase(MatcherBase&& other)
-      : vtable_(other.vtable_), buffer_(other.buffer_) {
-    other.vtable_ = nullptr;
-  }
-
-  MatcherBase& operator=(MatcherBase&& other) {
-    if (this == &other) return *this;
-    Destroy();
-    vtable_ = other.vtable_;
-    buffer_ = other.buffer_;
-    other.vtable_ = nullptr;
-    return *this;
-  }
-
-  ~MatcherBase() override { Destroy(); }
-
- private:
-  struct VTable {
-    bool (*match_and_explain)(const MatcherBase&, const T&,
-                              MatchResultListener*);
-    void (*describe)(const MatcherBase&, std::ostream*, bool negation);
-    // Returns the captured object if it implements the interface, otherwise
-    // returns the MatcherBase itself.
-    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&);
-    // Called on shared instances when the reference count reaches 0.
-    void (*shared_destroy)(SharedPayloadBase*);
-  };
-
-  bool IsShared() const {
-    return vtable_ != nullptr && vtable_->shared_destroy != nullptr;
-  }
-
-  // If the implementation uses a listener, call that.
-  template <typename P>
-  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
-                                  MatchResultListener* listener)
-      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) {
-    return P::Get(m).MatchAndExplain(value, listener->stream());
-  }
-
-  template <typename P>
-  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
-                                  MatchResultListener* listener)
-      -> decltype(P::Get(m).MatchAndExplain(value, listener)) {
-    return P::Get(m).MatchAndExplain(value, listener);
-  }
-
-  template <typename P>
-  static void DescribeImpl(const MatcherBase& m, std::ostream* os,
-                           bool negation) {
-    if (negation) {
-      P::Get(m).DescribeNegationTo(os);
-    } else {
-      P::Get(m).DescribeTo(os);
-    }
-  }
-
-  template <typename P>
-  static const MatcherDescriberInterface* GetDescriberImpl(
-      const MatcherBase& m) {
-    // If the impl is a MatcherDescriberInterface, then return it.
-    // Otherwise use MatcherBase itself.
-    // This allows us to implement the GetDescriber() function without support
-    // from the impl, but some users really want to get their impl back when
-    // they call GetDescriber().
-    // We use std::get on a tuple as a workaround of not having `if constexpr`.
-    return std::get<(
-        std::is_convertible<decltype(&P::Get(m)),
-                            const MatcherDescriberInterface*>::value
-            ? 1
-            : 0)>(std::make_tuple(&m, &P::Get(m)));
-  }
-
-  template <typename P>
-  const VTable* GetVTable() {
-    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>,
-                                       &DescribeImpl<P>, &GetDescriberImpl<P>,
-                                       P::shared_destroy};
-    return &kVTable;
-  }
-
-  union Buffer {
-    // Add some types to give Buffer some common alignment/size use cases.
-    void* ptr;
-    double d;
-    int64_t i;
-    // And add one for the out-of-line cases.
-    SharedPayloadBase* shared;
-  };
-
-  void Destroy() {
-    if (IsShared() && buffer_.shared->Unref()) {
-      vtable_->shared_destroy(buffer_.shared);
-    }
-  }
-
-  template <typename M>
-  static constexpr bool IsInlined() {
-    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
-           std::is_trivially_copy_constructible<M>::value &&
-           std::is_trivially_destructible<M>::value;
-  }
-
-  template <typename M, bool = MatcherBase::IsInlined<M>()>
-  struct ValuePolicy {
-    static const M& Get(const MatcherBase& m) {
-      // When inlined along with Init, need to be explicit to avoid violating
-      // strict aliasing rules.
-      const M *ptr = static_cast<const M*>(
-          static_cast<const void*>(&m.buffer_));
-      return *ptr;
-    }
-    static void Init(MatcherBase& m, M impl) {
-      ::new (static_cast<void*>(&m.buffer_)) M(impl);
-    }
-    static constexpr auto shared_destroy = nullptr;
-  };
-
-  template <typename M>
-  struct ValuePolicy<M, false> {
-    using Shared = SharedPayload<M>;
-    static const M& Get(const MatcherBase& m) {
-      return static_cast<Shared*>(m.buffer_.shared)->value;
-    }
-    template <typename Arg>
-    static void Init(MatcherBase& m, Arg&& arg) {
-      m.buffer_.shared = new Shared(std::forward<Arg>(arg));
-    }
-    static constexpr auto shared_destroy = &Shared::Destroy;
-  };
-
-  template <typename U, bool B>
-  struct ValuePolicy<const MatcherInterface<U>*, B> {
-    using M = const MatcherInterface<U>;
-    using Shared = SharedPayload<std::unique_ptr<M>>;
-    static const M& Get(const MatcherBase& m) {
-      return *static_cast<Shared*>(m.buffer_.shared)->value;
-    }
-    static void Init(MatcherBase& m, M* impl) {
-      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl));
-    }
-
-    static constexpr auto shared_destroy = &Shared::Destroy;
-  };
-
-  template <typename M>
-  void Init(M&& m) {
-    using MM = typename std::decay<M>::type;
-    using Policy = ValuePolicy<MM>;
-    vtable_ = GetVTable<Policy>();
-    Policy::Init(*this, std::forward<M>(m));
-  }
-
-  const VTable* vtable_;
-  Buffer buffer_;
-};
-
-}  // namespace internal
-
-// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
-// object that can check whether a value of type T matches.  The
-// implementation of Matcher<T> is just a std::shared_ptr to const
-// MatcherInterface<T>.  Don't inherit from Matcher!
-template <typename T>
-class Matcher : public internal::MatcherBase<T> {
- public:
-  // Constructs a null matcher.  Needed for storing Matcher objects in STL
-  // containers.  A default-constructed matcher is not yet initialized.  You
-  // cannot use it until a valid value has been assigned to it.
-  explicit Matcher() {}  // NOLINT
-
-  // Constructs a matcher from its implementation.
-  explicit Matcher(const MatcherInterface<const T&>* impl)
-      : internal::MatcherBase<T>(impl) {}
-
-  template <typename U>
-  explicit Matcher(
-      const MatcherInterface<U>* impl,
-      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
-          nullptr)
-      : internal::MatcherBase<T>(impl) {}
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT
-
-  // Implicit constructor here allows people to write
-  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
-  Matcher(T value);  // NOLINT
-};
-
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const std::string&>
-    : public internal::MatcherBase<const std::string&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const std::string&>* impl)
-      : internal::MatcherBase<const std::string&>(impl) {}
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  Matcher(M&& m)  // NOLINT
-      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<std::string>
-    : public internal::MatcherBase<std::string> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const std::string&>* impl)
-      : internal::MatcherBase<std::string>(impl) {}
-  explicit Matcher(const MatcherInterface<std::string>* impl)
-      : internal::MatcherBase<std::string>(impl) {}
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  Matcher(M&& m)  // NOLINT
-      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-};
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-// The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
-// matcher is expected.
-template <>
-class GTEST_API_ Matcher<const internal::StringView&>
-    : public internal::MatcherBase<const internal::StringView&> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
-      : internal::MatcherBase<const internal::StringView&>(impl) {}
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  Matcher(M&& m)  // NOLINT
-      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
-  }
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass absl::string_views or std::string_views directly.
-  Matcher(internal::StringView s);  // NOLINT
-};
-
-template <>
-class GTEST_API_ Matcher<internal::StringView>
-    : public internal::MatcherBase<internal::StringView> {
- public:
-  Matcher() {}
-
-  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
-      : internal::MatcherBase<internal::StringView>(impl) {}
-  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
-      : internal::MatcherBase<internal::StringView>(impl) {}
-
-  template <typename M, typename = typename std::remove_reference<
-                            M>::type::is_gtest_matcher>
-  Matcher(M&& m)  // NOLINT
-      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}
-
-  // Allows the user to write str instead of Eq(str) sometimes, where
-  // str is a std::string object.
-  Matcher(const std::string& s);  // NOLINT
-
-  // Allows the user to write "foo" instead of Eq("foo") sometimes.
-  Matcher(const char* s);  // NOLINT
-
-  // Allows the user to pass absl::string_views or std::string_views directly.
-  Matcher(internal::StringView s);  // NOLINT
-};
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-// Prints a matcher in a human-readable format.
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
-  matcher.DescribeTo(&os);
-  return os;
-}
-
-// The PolymorphicMatcher class template makes it easy to implement a
-// polymorphic matcher (i.e. a matcher that can match values of more
-// than one type, e.g. Eq(n) and NotNull()).
-//
-// To define a polymorphic matcher, a user should provide an Impl
-// class that has a DescribeTo() method and a DescribeNegationTo()
-// method, and define a member function (or member function template)
-//
-//   bool MatchAndExplain(const Value& value,
-//                        MatchResultListener* listener) const;
-//
-// See the definition of NotNull() for a complete example.
-template <class Impl>
-class PolymorphicMatcher {
- public:
-  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
-
-  // Returns a mutable reference to the underlying matcher
-  // implementation object.
-  Impl& mutable_impl() { return impl_; }
-
-  // Returns an immutable reference to the underlying matcher
-  // implementation object.
-  const Impl& impl() const { return impl_; }
-
-  template <typename T>
-  operator Matcher<T>() const {
-    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
-  }
-
- private:
-  template <typename T>
-  class MonomorphicImpl : public MatcherInterface<T> {
-   public:
-    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
-
-    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }
-
-    void DescribeNegationTo(::std::ostream* os) const override {
-      impl_.DescribeNegationTo(os);
-    }
-
-    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
-      return impl_.MatchAndExplain(x, listener);
-    }
-
-   private:
-    const Impl impl_;
-  };
-
-  Impl impl_;
-};
-
-// Creates a matcher from its implementation.
-// DEPRECATED: Especially in the generic code, prefer:
-//   Matcher<T>(new MyMatcherImpl<const T&>(...));
-//
-// MakeMatcher may create a Matcher that accepts its argument by value, which
-// leads to unnecessary copies & lack of support for non-copyable types.
-template <typename T>
-inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
-  return Matcher<T>(impl);
-}
-
-// Creates a polymorphic matcher from its implementation.  This is
-// easier to use than the PolymorphicMatcher<Impl> constructor as it
-// doesn't require you to explicitly write the template argument, e.g.
-//
-//   MakePolymorphicMatcher(foo);
-// vs
-//   PolymorphicMatcher<TypeOfFoo>(foo);
-template <class Impl>
-inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
-  return PolymorphicMatcher<Impl>(impl);
-}
-
-namespace internal {
-
-template <typename T>
-const T& Unwrap(const T& v) {
-  return v;
-}
-
-template <typename T>
-const T& Unwrap(std::reference_wrapper<T> v) {
-  return v;
-}
-
-// Implements a matcher that compares a given value with a
-// pre-supplied value using one of the ==, <=, <, etc, operators.  The
-// two values being compared don't have to have the same type.
-//
-// The matcher defined here is polymorphic (for example, Eq(5) can be
-// used to match an int, a short, a double, etc).  Therefore we use
-// a template type conversion operator in the implementation.
-//
-// The following template definition assumes that the Rhs parameter is
-// a "bare" type (i.e. neither 'const T' nor 'T&').
-template <typename D, typename Rhs, typename Op>
-class ComparisonBase {
- public:
-  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
-
-  using is_gtest_matcher = void;
-
-  template <typename Lhs>
-  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
-    return Op()(lhs, Unwrap(rhs_));
-  }
-  void DescribeTo(std::ostream* os) const {
-    *os << D::Desc() << " ";
-    UniversalPrint(Unwrap(rhs_), os);
-  }
-  void DescribeNegationTo(std::ostream* os) const {
-    *os << D::NegatedDesc() << " ";
-    UniversalPrint(Unwrap(rhs_), os);
-  }
-
- private:
-  Rhs rhs_;
-};
-
-template <typename Rhs>
-class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
- public:
-  explicit EqMatcher(const Rhs& rhs)
-      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
-  static const char* Desc() { return "is equal to"; }
-  static const char* NegatedDesc() { return "isn't equal to"; }
-};
-template <typename Rhs>
-class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
- public:
-  explicit NeMatcher(const Rhs& rhs)
-      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
-  static const char* Desc() { return "isn't equal to"; }
-  static const char* NegatedDesc() { return "is equal to"; }
-};
-template <typename Rhs>
-class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
- public:
-  explicit LtMatcher(const Rhs& rhs)
-      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
-  static const char* Desc() { return "is <"; }
-  static const char* NegatedDesc() { return "isn't <"; }
-};
-template <typename Rhs>
-class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
- public:
-  explicit GtMatcher(const Rhs& rhs)
-      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
-  static const char* Desc() { return "is >"; }
-  static const char* NegatedDesc() { return "isn't >"; }
-};
-template <typename Rhs>
-class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
- public:
-  explicit LeMatcher(const Rhs& rhs)
-      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
-  static const char* Desc() { return "is <="; }
-  static const char* NegatedDesc() { return "isn't <="; }
-};
-template <typename Rhs>
-class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
- public:
-  explicit GeMatcher(const Rhs& rhs)
-      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
-  static const char* Desc() { return "is >="; }
-  static const char* NegatedDesc() { return "isn't >="; }
-};
-
-template <typename T, typename = typename std::enable_if<
-                          std::is_constructible<std::string, T>::value>::type>
-using StringLike = T;
-
-// Implements polymorphic matchers MatchesRegex(regex) and
-// ContainsRegex(regex), which can be used as a Matcher<T> as long as
-// T can be converted to a string.
-class MatchesRegexMatcher {
- public:
-  MatchesRegexMatcher(const RE* regex, bool full_match)
-      : regex_(regex), full_match_(full_match) {}
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  bool MatchAndExplain(const internal::StringView& s,
-                       MatchResultListener* listener) const {
-    return MatchAndExplain(std::string(s), listener);
-  }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-  // Accepts pointer types, particularly:
-  //   const char*
-  //   char*
-  //   const wchar_t*
-  //   wchar_t*
-  template <typename CharType>
-  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
-    return s != nullptr && MatchAndExplain(std::string(s), listener);
-  }
-
-  // Matches anything that can convert to std::string.
-  //
-  // This is a template, not just a plain function with const std::string&,
-  // because absl::string_view has some interfering non-explicit constructors.
-  template <class MatcheeStringType>
-  bool MatchAndExplain(const MatcheeStringType& s,
-                       MatchResultListener* /* listener */) const {
-    const std::string& s2(s);
-    return full_match_ ? RE::FullMatch(s2, *regex_)
-                       : RE::PartialMatch(s2, *regex_);
-  }
-
-  void DescribeTo(::std::ostream* os) const {
-    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
-    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
-  }
-
-  void DescribeNegationTo(::std::ostream* os) const {
-    *os << "doesn't " << (full_match_ ? "match" : "contain")
-        << " regular expression ";
-    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
-  }
-
- private:
-  const std::shared_ptr<const RE> regex_;
-  const bool full_match_;
-};
-}  // namespace internal
-
-// Matches a string that fully matches regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
-}
-template <typename T = std::string>
-PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
-    const internal::StringLike<T>& regex) {
-  return MatchesRegex(new internal::RE(std::string(regex)));
-}
-
-// Matches a string that contains regular expression 'regex'.
-// The matcher takes ownership of 'regex'.
-inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::RE* regex) {
-  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
-}
-template <typename T = std::string>
-PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
-    const internal::StringLike<T>& regex) {
-  return ContainsRegex(new internal::RE(std::string(regex)));
-}
-
-// Creates a polymorphic matcher that matches anything equal to x.
-// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
-// wouldn't compile.
-template <typename T>
-inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
-
-// Constructs a Matcher<T> from a 'value' of type T.  The constructed
-// matcher matches any value that's equal to 'value'.
-template <typename T>
-Matcher<T>::Matcher(T value) { *this = Eq(value); }
-
-// Creates a monomorphic matcher that matches anything with type Lhs
-// and equal to rhs.  A user may need to use this instead of Eq(...)
-// in order to resolve an overloading ambiguity.
-//
-// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
-// or Matcher<T>(x), but more readable than the latter.
-//
-// We could define similar monomorphic matchers for other comparison
-// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
-// it yet as those are used much less than Eq() in practice.  A user
-// can always write Matcher<T>(Lt(5)) to be explicit about the type,
-// for example.
-template <typename Lhs, typename Rhs>
-inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
-
-// Creates a polymorphic matcher that matches anything >= x.
-template <typename Rhs>
-inline internal::GeMatcher<Rhs> Ge(Rhs x) {
-  return internal::GeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything > x.
-template <typename Rhs>
-inline internal::GtMatcher<Rhs> Gt(Rhs x) {
-  return internal::GtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything <= x.
-template <typename Rhs>
-inline internal::LeMatcher<Rhs> Le(Rhs x) {
-  return internal::LeMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything < x.
-template <typename Rhs>
-inline internal::LtMatcher<Rhs> Lt(Rhs x) {
-  return internal::LtMatcher<Rhs>(x);
-}
-
-// Creates a polymorphic matcher that matches anything != x.
-template <typename Rhs>
-inline internal::NeMatcher<Rhs> Ne(Rhs x) {
-  return internal::NeMatcher<Rhs>(x);
-}
-}  // namespace testing
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+// Copyright 2007, 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 file implements just enough of the matcher interface to allow 
+// EXPECT_DEATH and friends to accept a matcher argument. 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ 
+ 
+#include <atomic> 
+#include <memory> 
+#include <ostream> 
+#include <string> 
+#include <type_traits> 
+ 
+#include "gtest/gtest-printers.h" 
+#include "gtest/internal/gtest-internal.h" 
+#include "gtest/internal/gtest-port.h" 
+ 
+// MSVC warning C5046 is new as of VS2017 version 15.8. 
+#if defined(_MSC_VER) && _MSC_VER >= 1915 
+#define GTEST_MAYBE_5046_ 5046 
+#else 
+#define GTEST_MAYBE_5046_ 
+#endif 
+ 
+GTEST_DISABLE_MSC_WARNINGS_PUSH_( 
+    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by 
+                              clients of class B */ 
+    /* Symbol involving type with internal linkage not defined */) 
+ 
+namespace testing { 
+ 
+// To implement a matcher Foo for type T, define: 
+//   1. a class FooMatcherMatcher that implements the matcher interface: 
+//     using is_gtest_matcher = void; 
+//     bool MatchAndExplain(const T&, std::ostream*); 
+//       (MatchResultListener* can also be used instead of std::ostream*) 
+//     void DescribeTo(std::ostream*); 
+//     void DescribeNegationTo(std::ostream*); 
+// 
+//   2. a factory function that creates a Matcher<T> object from a 
+//      FooMatcherMatcher. 
+ 
+class MatchResultListener { 
+ public: 
+  // Creates a listener object with the given underlying ostream.  The 
+  // listener does not own the ostream, and does not dereference it 
+  // in the constructor or destructor. 
+  explicit MatchResultListener(::std::ostream* os) : stream_(os) {} 
+  virtual ~MatchResultListener() = 0;  // Makes this class abstract. 
+ 
+  // Streams x to the underlying ostream; does nothing if the ostream 
+  // is NULL. 
+  template <typename T> 
+  MatchResultListener& operator<<(const T& x) { 
+    if (stream_ != nullptr) *stream_ << x; 
+    return *this; 
+  } 
+ 
+  // Returns the underlying ostream. 
+  ::std::ostream* stream() { return stream_; } 
+ 
+  // Returns true if and only if the listener is interested in an explanation 
+  // of the match result.  A matcher's MatchAndExplain() method can use 
+  // this information to avoid generating the explanation when no one 
+  // intends to hear it. 
+  bool IsInterested() const { return stream_ != nullptr; } 
+ 
+ private: 
+  ::std::ostream* const stream_; 
+ 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener); 
+}; 
+ 
+inline MatchResultListener::~MatchResultListener() { 
+} 
+ 
+// An instance of a subclass of this knows how to describe itself as a 
+// matcher. 
+class GTEST_API_ MatcherDescriberInterface { 
+ public: 
+  virtual ~MatcherDescriberInterface() {} 
+ 
+  // Describes this matcher to an ostream.  The function should print 
+  // a verb phrase that describes the property a value matching this 
+  // matcher should have.  The subject of the verb phrase is the value 
+  // being matched.  For example, the DescribeTo() method of the Gt(7) 
+  // matcher prints "is greater than 7". 
+  virtual void DescribeTo(::std::ostream* os) const = 0; 
+ 
+  // Describes the negation of this matcher to an ostream.  For 
+  // example, if the description of this matcher is "is greater than 
+  // 7", the negated description could be "is not greater than 7". 
+  // You are not required to override this when implementing 
+  // MatcherInterface, but it is highly advised so that your matcher 
+  // can produce good error messages. 
+  virtual void DescribeNegationTo(::std::ostream* os) const { 
+    *os << "not ("; 
+    DescribeTo(os); 
+    *os << ")"; 
+  } 
+}; 
+ 
+// The implementation of a matcher. 
+template <typename T> 
+class MatcherInterface : public MatcherDescriberInterface { 
+ public: 
+  // Returns true if and only if the matcher matches x; also explains the 
+  // match result to 'listener' if necessary (see the next paragraph), in 
+  // the form of a non-restrictive relative clause ("which ...", 
+  // "whose ...", etc) that describes x.  For example, the 
+  // MatchAndExplain() method of the Pointee(...) matcher should 
+  // generate an explanation like "which points to ...". 
+  // 
+  // Implementations of MatchAndExplain() should add an explanation of 
+  // the match result *if and only if* they can provide additional 
+  // information that's not already present (or not obvious) in the 
+  // print-out of x and the matcher's description.  Whether the match 
+  // succeeds is not a factor in deciding whether an explanation is 
+  // needed, as sometimes the caller needs to print a failure message 
+  // when the match succeeds (e.g. when the matcher is used inside 
+  // Not()). 
+  // 
+  // For example, a "has at least 10 elements" matcher should explain 
+  // what the actual element count is, regardless of the match result, 
+  // as it is useful information to the reader; on the other hand, an 
+  // "is empty" matcher probably only needs to explain what the actual 
+  // size is when the match fails, as it's redundant to say that the 
+  // size is 0 when the value is already known to be empty. 
+  // 
+  // You should override this method when defining a new matcher. 
+  // 
+  // It's the responsibility of the caller (Google Test) to guarantee 
+  // that 'listener' is not NULL.  This helps to simplify a matcher's 
+  // implementation when it doesn't care about the performance, as it 
+  // can talk to 'listener' without checking its validity first. 
+  // However, in order to implement dummy listeners efficiently, 
+  // listener->stream() may be NULL. 
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; 
+ 
+  // Inherits these methods from MatcherDescriberInterface: 
+  //   virtual void DescribeTo(::std::ostream* os) const = 0; 
+  //   virtual void DescribeNegationTo(::std::ostream* os) const; 
+}; 
+ 
+namespace internal { 
+ 
+struct AnyEq { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a == b; } 
+}; 
+struct AnyNe { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a != b; } 
+}; 
+struct AnyLt { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a < b; } 
+}; 
+struct AnyGt { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a > b; } 
+}; 
+struct AnyLe { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a <= b; } 
+}; 
+struct AnyGe { 
+  template <typename A, typename B> 
+  bool operator()(const A& a, const B& b) const { return a >= b; } 
+}; 
+ 
+// A match result listener that ignores the explanation. 
+class DummyMatchResultListener : public MatchResultListener { 
+ public: 
+  DummyMatchResultListener() : MatchResultListener(nullptr) {} 
+ 
+ private: 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener); 
+}; 
+ 
+// A match result listener that forwards the explanation to a given 
+// ostream.  The difference between this and MatchResultListener is 
+// that the former is concrete. 
+class StreamMatchResultListener : public MatchResultListener { 
+ public: 
+  explicit StreamMatchResultListener(::std::ostream* os) 
+      : MatchResultListener(os) {} 
+ 
+ private: 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener); 
+}; 
+ 
+struct SharedPayloadBase { 
+  std::atomic<int> ref{1}; 
+  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); } 
+  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; } 
+}; 
+ 
+template <typename T> 
+struct SharedPayload : SharedPayloadBase { 
+  explicit SharedPayload(const T& v) : value(v) {} 
+  explicit SharedPayload(T&& v) : value(std::move(v)) {} 
+ 
+  static void Destroy(SharedPayloadBase* shared) { 
+    delete static_cast<SharedPayload*>(shared); 
+  } 
+ 
+  T value; 
+}; 
+ 
+// An internal class for implementing Matcher<T>, which will derive 
+// from it.  We put functionalities common to all Matcher<T> 
+// specializations here to avoid code duplication. 
+template <typename T> 
+class MatcherBase : private MatcherDescriberInterface { 
+ public: 
+  // Returns true if and only if the matcher matches x; also explains the 
+  // match result to 'listener'. 
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const { 
+    GTEST_CHECK_(vtable_ != nullptr); 
+    return vtable_->match_and_explain(*this, x, listener); 
+  } 
+ 
+  // Returns true if and only if this matcher matches x. 
+  bool Matches(const T& x) const { 
+    DummyMatchResultListener dummy; 
+    return MatchAndExplain(x, &dummy); 
+  } 
+ 
+  // Describes this matcher to an ostream. 
+  void DescribeTo(::std::ostream* os) const final { 
+    GTEST_CHECK_(vtable_ != nullptr); 
+    vtable_->describe(*this, os, false); 
+  } 
+ 
+  // Describes the negation of this matcher to an ostream. 
+  void DescribeNegationTo(::std::ostream* os) const final { 
+    GTEST_CHECK_(vtable_ != nullptr); 
+    vtable_->describe(*this, os, true); 
+  } 
+ 
+  // Explains why x matches, or doesn't match, the matcher. 
+  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const { 
+    StreamMatchResultListener listener(os); 
+    MatchAndExplain(x, &listener); 
+  } 
+ 
+  // Returns the describer for this matcher object; retains ownership 
+  // of the describer, which is only guaranteed to be alive when 
+  // this matcher object is alive. 
+  const MatcherDescriberInterface* GetDescriber() const { 
+    if (vtable_ == nullptr) return nullptr; 
+    return vtable_->get_describer(*this); 
+  } 
+ 
+ protected: 
+  MatcherBase() : vtable_(nullptr) {} 
+ 
+  // Constructs a matcher from its implementation. 
+  template <typename U> 
+  explicit MatcherBase(const MatcherInterface<U>* impl) { 
+    Init(impl); 
+  } 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  MatcherBase(M&& m) {  // NOLINT 
+    Init(std::forward<M>(m)); 
+  } 
+ 
+  MatcherBase(const MatcherBase& other) 
+      : vtable_(other.vtable_), buffer_(other.buffer_) { 
+    if (IsShared()) buffer_.shared->Ref(); 
+  } 
+ 
+  MatcherBase& operator=(const MatcherBase& other) { 
+    if (this == &other) return *this; 
+    Destroy(); 
+    vtable_ = other.vtable_; 
+    buffer_ = other.buffer_; 
+    if (IsShared()) buffer_.shared->Ref(); 
+    return *this; 
+  } 
+ 
+  MatcherBase(MatcherBase&& other) 
+      : vtable_(other.vtable_), buffer_(other.buffer_) { 
+    other.vtable_ = nullptr; 
+  } 
+ 
+  MatcherBase& operator=(MatcherBase&& other) { 
+    if (this == &other) return *this; 
+    Destroy(); 
+    vtable_ = other.vtable_; 
+    buffer_ = other.buffer_; 
+    other.vtable_ = nullptr; 
+    return *this; 
+  } 
+ 
+  ~MatcherBase() override { Destroy(); } 
+ 
+ private: 
+  struct VTable { 
+    bool (*match_and_explain)(const MatcherBase&, const T&, 
+                              MatchResultListener*); 
+    void (*describe)(const MatcherBase&, std::ostream*, bool negation); 
+    // Returns the captured object if it implements the interface, otherwise 
+    // returns the MatcherBase itself. 
+    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&); 
+    // Called on shared instances when the reference count reaches 0. 
+    void (*shared_destroy)(SharedPayloadBase*); 
+  }; 
+ 
+  bool IsShared() const { 
+    return vtable_ != nullptr && vtable_->shared_destroy != nullptr; 
+  } 
+ 
+  // If the implementation uses a listener, call that. 
+  template <typename P> 
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value, 
+                                  MatchResultListener* listener) 
+      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) { 
+    return P::Get(m).MatchAndExplain(value, listener->stream()); 
+  } 
+ 
+  template <typename P> 
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value, 
+                                  MatchResultListener* listener) 
+      -> decltype(P::Get(m).MatchAndExplain(value, listener)) { 
+    return P::Get(m).MatchAndExplain(value, listener); 
+  } 
+ 
+  template <typename P> 
+  static void DescribeImpl(const MatcherBase& m, std::ostream* os, 
+                           bool negation) { 
+    if (negation) { 
+      P::Get(m).DescribeNegationTo(os); 
+    } else { 
+      P::Get(m).DescribeTo(os); 
+    } 
+  } 
+ 
+  template <typename P> 
+  static const MatcherDescriberInterface* GetDescriberImpl( 
+      const MatcherBase& m) { 
+    // If the impl is a MatcherDescriberInterface, then return it. 
+    // Otherwise use MatcherBase itself. 
+    // This allows us to implement the GetDescriber() function without support 
+    // from the impl, but some users really want to get their impl back when 
+    // they call GetDescriber(). 
+    // We use std::get on a tuple as a workaround of not having `if constexpr`. 
+    return std::get<( 
+        std::is_convertible<decltype(&P::Get(m)), 
+                            const MatcherDescriberInterface*>::value 
+            ? 1 
+            : 0)>(std::make_tuple(&m, &P::Get(m))); 
+  } 
+ 
+  template <typename P> 
+  const VTable* GetVTable() { 
+    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>, 
+                                       &DescribeImpl<P>, &GetDescriberImpl<P>, 
+                                       P::shared_destroy}; 
+    return &kVTable; 
+  } 
+ 
+  union Buffer { 
+    // Add some types to give Buffer some common alignment/size use cases. 
+    void* ptr; 
+    double d; 
+    int64_t i; 
+    // And add one for the out-of-line cases. 
+    SharedPayloadBase* shared; 
+  }; 
+ 
+  void Destroy() { 
+    if (IsShared() && buffer_.shared->Unref()) { 
+      vtable_->shared_destroy(buffer_.shared); 
+    } 
+  } 
+ 
+  template <typename M> 
+  static constexpr bool IsInlined() { 
+    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) && 
+           std::is_trivially_copy_constructible<M>::value && 
+           std::is_trivially_destructible<M>::value; 
+  } 
+ 
+  template <typename M, bool = MatcherBase::IsInlined<M>()> 
+  struct ValuePolicy { 
+    static const M& Get(const MatcherBase& m) { 
+      // When inlined along with Init, need to be explicit to avoid violating 
+      // strict aliasing rules. 
+      const M *ptr = static_cast<const M*>( 
+          static_cast<const void*>(&m.buffer_)); 
+      return *ptr; 
+    } 
+    static void Init(MatcherBase& m, M impl) { 
+      ::new (static_cast<void*>(&m.buffer_)) M(impl); 
+    } 
+    static constexpr auto shared_destroy = nullptr; 
+  }; 
+ 
+  template <typename M> 
+  struct ValuePolicy<M, false> { 
+    using Shared = SharedPayload<M>; 
+    static const M& Get(const MatcherBase& m) { 
+      return static_cast<Shared*>(m.buffer_.shared)->value; 
+    } 
+    template <typename Arg> 
+    static void Init(MatcherBase& m, Arg&& arg) { 
+      m.buffer_.shared = new Shared(std::forward<Arg>(arg)); 
+    } 
+    static constexpr auto shared_destroy = &Shared::Destroy; 
+  }; 
+ 
+  template <typename U, bool B> 
+  struct ValuePolicy<const MatcherInterface<U>*, B> { 
+    using M = const MatcherInterface<U>; 
+    using Shared = SharedPayload<std::unique_ptr<M>>; 
+    static const M& Get(const MatcherBase& m) { 
+      return *static_cast<Shared*>(m.buffer_.shared)->value; 
+    } 
+    static void Init(MatcherBase& m, M* impl) { 
+      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl)); 
+    } 
+ 
+    static constexpr auto shared_destroy = &Shared::Destroy; 
+  }; 
+ 
+  template <typename M> 
+  void Init(M&& m) { 
+    using MM = typename std::decay<M>::type; 
+    using Policy = ValuePolicy<MM>; 
+    vtable_ = GetVTable<Policy>(); 
+    Policy::Init(*this, std::forward<M>(m)); 
+  } 
+ 
+  const VTable* vtable_; 
+  Buffer buffer_; 
+}; 
+ 
+}  // namespace internal 
+ 
+// A Matcher<T> is a copyable and IMMUTABLE (except by assignment) 
+// object that can check whether a value of type T matches.  The 
+// implementation of Matcher<T> is just a std::shared_ptr to const 
+// MatcherInterface<T>.  Don't inherit from Matcher! 
+template <typename T> 
+class Matcher : public internal::MatcherBase<T> { 
+ public: 
+  // Constructs a null matcher.  Needed for storing Matcher objects in STL 
+  // containers.  A default-constructed matcher is not yet initialized.  You 
+  // cannot use it until a valid value has been assigned to it. 
+  explicit Matcher() {}  // NOLINT 
+ 
+  // Constructs a matcher from its implementation. 
+  explicit Matcher(const MatcherInterface<const T&>* impl) 
+      : internal::MatcherBase<T>(impl) {} 
+ 
+  template <typename U> 
+  explicit Matcher( 
+      const MatcherInterface<U>* impl, 
+      typename std::enable_if<!std::is_same<U, const U&>::value>::type* = 
+          nullptr) 
+      : internal::MatcherBase<T>(impl) {} 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT 
+ 
+  // Implicit constructor here allows people to write 
+  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes 
+  Matcher(T value);  // NOLINT 
+}; 
+ 
+// The following two specializations allow the user to write str 
+// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string 
+// matcher is expected. 
+template <> 
+class GTEST_API_ Matcher<const std::string&> 
+    : public internal::MatcherBase<const std::string&> { 
+ public: 
+  Matcher() {} 
+ 
+  explicit Matcher(const MatcherInterface<const std::string&>* impl) 
+      : internal::MatcherBase<const std::string&>(impl) {} 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  Matcher(M&& m)  // NOLINT 
+      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {} 
+ 
+  // Allows the user to write str instead of Eq(str) sometimes, where 
+  // str is a std::string object. 
+  Matcher(const std::string& s);  // NOLINT 
+ 
+  // Allows the user to write "foo" instead of Eq("foo") sometimes. 
+  Matcher(const char* s);  // NOLINT 
+}; 
+ 
+template <> 
+class GTEST_API_ Matcher<std::string> 
+    : public internal::MatcherBase<std::string> { 
+ public: 
+  Matcher() {} 
+ 
+  explicit Matcher(const MatcherInterface<const std::string&>* impl) 
+      : internal::MatcherBase<std::string>(impl) {} 
+  explicit Matcher(const MatcherInterface<std::string>* impl) 
+      : internal::MatcherBase<std::string>(impl) {} 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  Matcher(M&& m)  // NOLINT 
+      : internal::MatcherBase<std::string>(std::forward<M>(m)) {} 
+ 
+  // Allows the user to write str instead of Eq(str) sometimes, where 
+  // str is a string object. 
+  Matcher(const std::string& s);  // NOLINT 
+ 
+  // Allows the user to write "foo" instead of Eq("foo") sometimes. 
+  Matcher(const char* s);  // NOLINT 
+}; 
+ 
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+// The following two specializations allow the user to write str 
+// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view 
+// matcher is expected. 
+template <> 
+class GTEST_API_ Matcher<const internal::StringView&> 
+    : public internal::MatcherBase<const internal::StringView&> { 
+ public: 
+  Matcher() {} 
+ 
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) 
+      : internal::MatcherBase<const internal::StringView&>(impl) {} 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  Matcher(M&& m)  // NOLINT 
+      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) { 
+  } 
+ 
+  // Allows the user to write str instead of Eq(str) sometimes, where 
+  // str is a std::string object. 
+  Matcher(const std::string& s);  // NOLINT 
+ 
+  // Allows the user to write "foo" instead of Eq("foo") sometimes. 
+  Matcher(const char* s);  // NOLINT 
+ 
+  // Allows the user to pass absl::string_views or std::string_views directly. 
+  Matcher(internal::StringView s);  // NOLINT 
+}; 
+ 
+template <> 
+class GTEST_API_ Matcher<internal::StringView> 
+    : public internal::MatcherBase<internal::StringView> { 
+ public: 
+  Matcher() {} 
+ 
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) 
+      : internal::MatcherBase<internal::StringView>(impl) {} 
+  explicit Matcher(const MatcherInterface<internal::StringView>* impl) 
+      : internal::MatcherBase<internal::StringView>(impl) {} 
+ 
+  template <typename M, typename = typename std::remove_reference< 
+                            M>::type::is_gtest_matcher> 
+  Matcher(M&& m)  // NOLINT 
+      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {} 
+ 
+  // Allows the user to write str instead of Eq(str) sometimes, where 
+  // str is a std::string object. 
+  Matcher(const std::string& s);  // NOLINT 
+ 
+  // Allows the user to write "foo" instead of Eq("foo") sometimes. 
+  Matcher(const char* s);  // NOLINT 
+ 
+  // Allows the user to pass absl::string_views or std::string_views directly. 
+  Matcher(internal::StringView s);  // NOLINT 
+}; 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
+// Prints a matcher in a human-readable format. 
+template <typename T> 
+std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) { 
+  matcher.DescribeTo(&os); 
+  return os; 
+} 
+ 
+// The PolymorphicMatcher class template makes it easy to implement a 
+// polymorphic matcher (i.e. a matcher that can match values of more 
+// than one type, e.g. Eq(n) and NotNull()). 
+// 
+// To define a polymorphic matcher, a user should provide an Impl 
+// class that has a DescribeTo() method and a DescribeNegationTo() 
+// method, and define a member function (or member function template) 
+// 
+//   bool MatchAndExplain(const Value& value, 
+//                        MatchResultListener* listener) const; 
+// 
+// See the definition of NotNull() for a complete example. 
+template <class Impl> 
+class PolymorphicMatcher { 
+ public: 
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {} 
+ 
+  // Returns a mutable reference to the underlying matcher 
+  // implementation object. 
+  Impl& mutable_impl() { return impl_; } 
+ 
+  // Returns an immutable reference to the underlying matcher 
+  // implementation object. 
+  const Impl& impl() const { return impl_; } 
+ 
+  template <typename T> 
+  operator Matcher<T>() const { 
+    return Matcher<T>(new MonomorphicImpl<const T&>(impl_)); 
+  } 
+ 
+ private: 
+  template <typename T> 
+  class MonomorphicImpl : public MatcherInterface<T> { 
+   public: 
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} 
+ 
+    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); } 
+ 
+    void DescribeNegationTo(::std::ostream* os) const override { 
+      impl_.DescribeNegationTo(os); 
+    } 
+ 
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override { 
+      return impl_.MatchAndExplain(x, listener); 
+    } 
+ 
+   private: 
+    const Impl impl_; 
+  }; 
+ 
+  Impl impl_; 
+}; 
+ 
+// Creates a matcher from its implementation. 
+// DEPRECATED: Especially in the generic code, prefer: 
+//   Matcher<T>(new MyMatcherImpl<const T&>(...)); 
+// 
+// MakeMatcher may create a Matcher that accepts its argument by value, which 
+// leads to unnecessary copies & lack of support for non-copyable types. 
+template <typename T> 
+inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) { 
+  return Matcher<T>(impl); 
+} 
+ 
+// Creates a polymorphic matcher from its implementation.  This is 
+// easier to use than the PolymorphicMatcher<Impl> constructor as it 
+// doesn't require you to explicitly write the template argument, e.g. 
+// 
+//   MakePolymorphicMatcher(foo); 
+// vs 
+//   PolymorphicMatcher<TypeOfFoo>(foo); 
+template <class Impl> 
+inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) { 
+  return PolymorphicMatcher<Impl>(impl); 
+} 
+ 
+namespace internal { 
+ 
+template <typename T> 
+const T& Unwrap(const T& v) { 
+  return v; 
+} 
+ 
+template <typename T> 
+const T& Unwrap(std::reference_wrapper<T> v) { 
+  return v; 
+} 
+ 
+// Implements a matcher that compares a given value with a 
+// pre-supplied value using one of the ==, <=, <, etc, operators.  The 
+// two values being compared don't have to have the same type. 
+// 
+// The matcher defined here is polymorphic (for example, Eq(5) can be 
+// used to match an int, a short, a double, etc).  Therefore we use 
+// a template type conversion operator in the implementation. 
+// 
+// The following template definition assumes that the Rhs parameter is 
+// a "bare" type (i.e. neither 'const T' nor 'T&'). 
+template <typename D, typename Rhs, typename Op> 
+class ComparisonBase { 
+ public: 
+  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {} 
+ 
+  using is_gtest_matcher = void; 
+ 
+  template <typename Lhs> 
+  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const { 
+    return Op()(lhs, Unwrap(rhs_)); 
+  } 
+  void DescribeTo(std::ostream* os) const { 
+    *os << D::Desc() << " "; 
+    UniversalPrint(Unwrap(rhs_), os); 
+  } 
+  void DescribeNegationTo(std::ostream* os) const { 
+    *os << D::NegatedDesc() << " "; 
+    UniversalPrint(Unwrap(rhs_), os); 
+  } 
+ 
+ private: 
+  Rhs rhs_; 
+}; 
+ 
+template <typename Rhs> 
+class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> { 
+ public: 
+  explicit EqMatcher(const Rhs& rhs) 
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { } 
+  static const char* Desc() { return "is equal to"; } 
+  static const char* NegatedDesc() { return "isn't equal to"; } 
+}; 
+template <typename Rhs> 
+class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> { 
+ public: 
+  explicit NeMatcher(const Rhs& rhs) 
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { } 
+  static const char* Desc() { return "isn't equal to"; } 
+  static const char* NegatedDesc() { return "is equal to"; } 
+}; 
+template <typename Rhs> 
+class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> { 
+ public: 
+  explicit LtMatcher(const Rhs& rhs) 
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { } 
+  static const char* Desc() { return "is <"; } 
+  static const char* NegatedDesc() { return "isn't <"; } 
+}; 
+template <typename Rhs> 
+class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> { 
+ public: 
+  explicit GtMatcher(const Rhs& rhs) 
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { } 
+  static const char* Desc() { return "is >"; } 
+  static const char* NegatedDesc() { return "isn't >"; } 
+}; 
+template <typename Rhs> 
+class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> { 
+ public: 
+  explicit LeMatcher(const Rhs& rhs) 
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { } 
+  static const char* Desc() { return "is <="; } 
+  static const char* NegatedDesc() { return "isn't <="; } 
+}; 
+template <typename Rhs> 
+class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> { 
+ public: 
+  explicit GeMatcher(const Rhs& rhs) 
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { } 
+  static const char* Desc() { return "is >="; } 
+  static const char* NegatedDesc() { return "isn't >="; } 
+}; 
+ 
+template <typename T, typename = typename std::enable_if< 
+                          std::is_constructible<std::string, T>::value>::type> 
+using StringLike = T; 
+ 
+// Implements polymorphic matchers MatchesRegex(regex) and 
+// ContainsRegex(regex), which can be used as a Matcher<T> as long as 
+// T can be converted to a string. 
+class MatchesRegexMatcher { 
+ public: 
+  MatchesRegexMatcher(const RE* regex, bool full_match) 
+      : regex_(regex), full_match_(full_match) {} 
+ 
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  bool MatchAndExplain(const internal::StringView& s, 
+                       MatchResultListener* listener) const { 
+    return MatchAndExplain(std::string(s), listener); 
+  } 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
+  // Accepts pointer types, particularly: 
+  //   const char* 
+  //   char* 
+  //   const wchar_t* 
+  //   wchar_t* 
+  template <typename CharType> 
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const { 
+    return s != nullptr && MatchAndExplain(std::string(s), listener); 
+  } 
+ 
+  // Matches anything that can convert to std::string. 
+  // 
+  // This is a template, not just a plain function with const std::string&, 
+  // because absl::string_view has some interfering non-explicit constructors. 
+  template <class MatcheeStringType> 
+  bool MatchAndExplain(const MatcheeStringType& s, 
+                       MatchResultListener* /* listener */) const { 
+    const std::string& s2(s); 
+    return full_match_ ? RE::FullMatch(s2, *regex_) 
+                       : RE::PartialMatch(s2, *regex_); 
+  } 
+ 
+  void DescribeTo(::std::ostream* os) const { 
+    *os << (full_match_ ? "matches" : "contains") << " regular expression "; 
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os); 
+  } 
+ 
+  void DescribeNegationTo(::std::ostream* os) const { 
+    *os << "doesn't " << (full_match_ ? "match" : "contain") 
+        << " regular expression "; 
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os); 
+  } 
+ 
+ private: 
+  const std::shared_ptr<const RE> regex_; 
+  const bool full_match_; 
+}; 
+}  // namespace internal 
+ 
+// Matches a string that fully matches regular expression 'regex'. 
+// The matcher takes ownership of 'regex'. 
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( 
+    const internal::RE* regex) { 
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true)); 
+} 
+template <typename T = std::string> 
+PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex( 
+    const internal::StringLike<T>& regex) { 
+  return MatchesRegex(new internal::RE(std::string(regex))); 
+} 
+ 
+// Matches a string that contains regular expression 'regex'. 
+// The matcher takes ownership of 'regex'. 
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( 
+    const internal::RE* regex) { 
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false)); 
+} 
+template <typename T = std::string> 
+PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex( 
+    const internal::StringLike<T>& regex) { 
+  return ContainsRegex(new internal::RE(std::string(regex))); 
+} 
+ 
+// Creates a polymorphic matcher that matches anything equal to x. 
+// Note: if the parameter of Eq() were declared as const T&, Eq("foo") 
+// wouldn't compile. 
+template <typename T> 
+inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); } 
+ 
+// Constructs a Matcher<T> from a 'value' of type T.  The constructed 
+// matcher matches any value that's equal to 'value'. 
+template <typename T> 
+Matcher<T>::Matcher(T value) { *this = Eq(value); } 
+ 
+// Creates a monomorphic matcher that matches anything with type Lhs 
+// and equal to rhs.  A user may need to use this instead of Eq(...) 
+// in order to resolve an overloading ambiguity. 
+// 
+// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x)) 
+// or Matcher<T>(x), but more readable than the latter. 
+// 
+// We could define similar monomorphic matchers for other comparison 
+// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do 
+// it yet as those are used much less than Eq() in practice.  A user 
+// can always write Matcher<T>(Lt(5)) to be explicit about the type, 
+// for example. 
+template <typename Lhs, typename Rhs> 
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); } 
+ 
+// Creates a polymorphic matcher that matches anything >= x. 
+template <typename Rhs> 
+inline internal::GeMatcher<Rhs> Ge(Rhs x) { 
+  return internal::GeMatcher<Rhs>(x); 
+} 
+ 
+// Creates a polymorphic matcher that matches anything > x. 
+template <typename Rhs> 
+inline internal::GtMatcher<Rhs> Gt(Rhs x) { 
+  return internal::GtMatcher<Rhs>(x); 
+} 
+ 
+// Creates a polymorphic matcher that matches anything <= x. 
+template <typename Rhs> 
+inline internal::LeMatcher<Rhs> Le(Rhs x) { 
+  return internal::LeMatcher<Rhs>(x); 
+} 
+ 
+// Creates a polymorphic matcher that matches anything < x. 
+template <typename Rhs> 
+inline internal::LtMatcher<Rhs> Lt(Rhs x) { 
+  return internal::LtMatcher<Rhs>(x); 
+} 
+ 
+// Creates a polymorphic matcher that matches anything != x. 
+template <typename Rhs> 
+inline internal::NeMatcher<Rhs> Ne(Rhs x) { 
+  return internal::NeMatcher<Rhs>(x); 
+} 
+}  // namespace testing 
+ 
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-message.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-message.h
index becfd49fcb..5ad1f9244a 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-message.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-message.h
@@ -26,9 +26,9 @@
 // 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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file defines the Message class.
 //
@@ -42,20 +42,20 @@
 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
 // program!
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 
 
 #include <limits>
-#include <memory>
-#include <sstream>
+#include <memory> 
+#include <sstream> 
 
 #include "gtest/internal/gtest-port.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 // Ensures that there is at least one operator<< in the global namespace.
 // See Message& operator<<(...) below for why.
 void operator<<(const testing::internal::Secret&, int);
@@ -145,7 +145,7 @@ class GTEST_API_ Message {
   // as "(null)".
   template <typename T>
   inline Message& operator <<(T* const& pointer) {  // NOLINT
-    if (pointer == nullptr) {
+    if (pointer == nullptr) { 
       *ss_ << "(null)";
     } else {
       *ss_ << pointer;
@@ -188,7 +188,7 @@ class GTEST_API_ Message {
 
  private:
   // We'll hold the text streamed to this object here.
-  const std::unique_ptr< ::std::stringstream> ss_;
+  const std::unique_ptr< ::std::stringstream> ss_; 
 
   // We declare (but don't implement) this to prevent the compiler
   // from implementing the assignment operator.
@@ -214,6 +214,6 @@ std::string StreamableToString(const T& streamable) {
 }  // namespace internal
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-param-test.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-param-test.h
index 804e702817..5b49d411c5 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-param-test.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-param-test.h
@@ -28,11 +28,11 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Macros and functions for implementing parameterized tests
-// in Google C++ Testing and Mocking Framework (Google Test)
+// in Google C++ Testing and Mocking Framework (Google Test) 
 //
-// GOOGLETEST_CM0001 DO NOT DELETE
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ 
 
 // Value-parameterized tests allow you to test your code with different
 // parameters without writing multiple copies of the same test.
@@ -68,10 +68,10 @@ TEST_P(FooTest, HasBlahBlah) {
   ...
 }
 
-// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
+// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test 
 // case with any set of parameters you want. Google Test defines a number
 // of functions for generating test parameters. They return what we call
-// (surprise!) parameter generators. Here is a summary of them, which
+// (surprise!) parameter generators. Here is a summary of them, which 
 // are all in the testing namespace:
 //
 //
@@ -89,17 +89,17 @@ TEST_P(FooTest, HasBlahBlah) {
 // For more details, see comments at the definitions of these functions below
 // in this file.
 //
-// The following statement will instantiate tests from the FooTest test suite
+// The following statement will instantiate tests from the FooTest test suite 
 // each with parameter values "meeny", "miny", and "moe".
 
-INSTANTIATE_TEST_SUITE_P(InstantiationName,
-                         FooTest,
-                         Values("meeny", "miny", "moe"));
+INSTANTIATE_TEST_SUITE_P(InstantiationName, 
+                         FooTest, 
+                         Values("meeny", "miny", "moe")); 
 
 // To distinguish different instances of the pattern, (yes, you
-// can instantiate it more than once) the first argument to the
-// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
-// actual test suite name. Remember to pick unique prefixes for different
+// can instantiate it more than once) the first argument to the 
+// INSTANTIATE_TEST_SUITE_P macro 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:
 //
@@ -116,7 +116,7 @@ INSTANTIATE_TEST_SUITE_P(InstantiationName,
 // with parameter values "cat" and "dog":
 
 const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); 
 
 // The tests from the instantiation above will have these names:
 //
@@ -125,9 +125,9 @@ INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
 //    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
 //    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
 //
-// 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.
+// 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. 
 //
 // Please also note that generator expressions (including parameters to the
 // generators) are evaluated in InitGoogleTest(), after main() has started.
@@ -171,23 +171,23 @@ TEST_P(DerivedTest, DoesBlah) {
 
 #endif  // 0
 
-#include <iterator>
-#include <utility>
+#include <iterator> 
+#include <utility> 
 
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-param-util.h"
-#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-port.h" 
 
 namespace testing {
 
 // Functions producing parameter generators.
 //
 // Google Test uses these generators to produce parameters for value-
-// parameterized tests. When a parameterized test suite is instantiated
+// parameterized tests. When a parameterized test suite is instantiated 
 // with a particular generator, Google Test creates and runs tests
 // for each element in the sequence produced by the generator.
 //
-// In the following sample, tests from test suite FooTest are instantiated
+// In the following sample, tests from test suite FooTest are instantiated 
 // each three times with parameter values 3, 5, and 8:
 //
 // class FooTest : public TestWithParam<int> { ... };
@@ -196,7 +196,7 @@ namespace testing {
 // }
 // TEST_P(FooTest, TestThat) {
 // }
-// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
+// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8)); 
 //
 
 // Range() returns generators providing sequences of values in a range.
@@ -253,13 +253,13 @@ internal::ParamGenerator<T> Range(T start, T end) {
 //
 // Examples:
 //
-// This instantiates tests from test suite StringTest
+// This instantiates tests from test suite StringTest 
 // each with C-string values of "foo", "bar", and "baz":
 //
 // const char* strings[] = {"foo", "bar", "baz"};
-// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
+// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings)); 
 //
-// This instantiates tests from test suite StlStringTest
+// This instantiates tests from test suite StlStringTest 
 // each with STL strings with values "a" and "b":
 //
 // ::std::vector< ::std::string> GetParameterStrings() {
@@ -269,9 +269,9 @@ internal::ParamGenerator<T> Range(T start, T end) {
 //   return v;
 // }
 //
-// INSTANTIATE_TEST_SUITE_P(CharSequence,
-//                          StlStringTest,
-//                          ValuesIn(GetParameterStrings()));
+// INSTANTIATE_TEST_SUITE_P(CharSequence, 
+//                          StlStringTest, 
+//                          ValuesIn(GetParameterStrings())); 
 //
 //
 // This will also instantiate tests from CharTest
@@ -284,15 +284,15 @@ internal::ParamGenerator<T> Range(T start, T end) {
 //   return list;
 // }
 // ::std::list<char> l = GetParameterChars();
-// INSTANTIATE_TEST_SUITE_P(CharSequence2,
-//                          CharTest,
-//                          ValuesIn(l.begin(), l.end()));
+// INSTANTIATE_TEST_SUITE_P(CharSequence2, 
+//                          CharTest, 
+//                          ValuesIn(l.begin(), l.end())); 
 //
 template <typename ForwardIterator>
 internal::ParamGenerator<
-    typename std::iterator_traits<ForwardIterator>::value_type>
+    typename std::iterator_traits<ForwardIterator>::value_type> 
 ValuesIn(ForwardIterator begin, ForwardIterator end) {
-  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
+  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType; 
   return internal::ParamGenerator<ParamType>(
       new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
 }
@@ -315,22 +315,22 @@ internal::ParamGenerator<typename Container::value_type> ValuesIn(
 // Values(T v1, T v2, ..., T vN)
 //   - returns a generator producing sequences with elements v1, v2, ..., vN.
 //
-// For example, this instantiates tests from test suite BarTest each
+// For example, this instantiates tests from test suite BarTest each 
 // with values "one", "two", and "three":
 //
-// INSTANTIATE_TEST_SUITE_P(NumSequence,
-//                          BarTest,
-//                          Values("one", "two", "three"));
+// INSTANTIATE_TEST_SUITE_P(NumSequence, 
+//                          BarTest, 
+//                          Values("one", "two", "three")); 
 //
-// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
+// This instantiates tests from test suite BazTest each with values 1, 2, 3.5. 
 // The exact type of values will depend on the type of parameter in BazTest.
 //
-// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); 
 //
 //
-template <typename... T>
-internal::ValueArray<T...> Values(T... v) {
-  return internal::ValueArray<T...>(std::move(v)...);
+template <typename... T> 
+internal::ValueArray<T...> Values(T... v) { 
+  return internal::ValueArray<T...>(std::move(v)...); 
 }
 
 // Bool() allows generating tests with parameters in a set of (false, true).
@@ -343,7 +343,7 @@ internal::ValueArray<T...> Values(T... v) {
 // of multiple flags can be tested when several Bool()'s are combined using
 // Combine() function.
 //
-// In the following example all tests in the test suite FlagDependentTest
+// In the following example all tests in the test suite FlagDependentTest 
 // will be instantiated twice with parameters false and true.
 //
 // class FlagDependentTest : public testing::TestWithParam<bool> {
@@ -351,7 +351,7 @@ internal::ValueArray<T...> Values(T... v) {
 //     external_flag = GetParam();
 //   }
 // }
-// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
+// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool()); 
 //
 inline internal::ParamGenerator<bool> Bool() {
   return Values(false, true);
@@ -365,143 +365,143 @@ inline internal::ParamGenerator<bool> Bool() {
 //   - returns a generator producing sequences with elements coming from
 //     the Cartesian product of elements from the sequences generated by
 //     gen1, gen2, ..., genN. The sequence elements will have a type of
-//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types 
 //     of elements from sequences produces by gen1, gen2, ..., genN.
 //
 // Example:
 //
-// This will instantiate tests in test suite AnimalTest each one with
+// This will instantiate tests in test suite AnimalTest each one with 
 // the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
 // tuple("dog", BLACK), and tuple("dog", WHITE):
 //
 // enum Color { BLACK, GRAY, WHITE };
 // class AnimalTest
-//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
+//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...}; 
 //
 // TEST_P(AnimalTest, AnimalLooksNice) {...}
 //
-// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
-//                          Combine(Values("cat", "dog"),
-//                                  Values(BLACK, WHITE)));
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest, 
+//                          Combine(Values("cat", "dog"), 
+//                                  Values(BLACK, WHITE))); 
 //
 // This will instantiate tests in FlagDependentTest with all variations of two
 // Boolean flags:
 //
 // class FlagDependentTest
-//     : public testing::TestWithParam<std::tuple<bool, bool> > {
+//     : public testing::TestWithParam<std::tuple<bool, bool> > { 
 //   virtual void SetUp() {
 //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
-//     std::tie(external_flag_1, external_flag_2) = GetParam();
+//     std::tie(external_flag_1, external_flag_2) = GetParam(); 
 //   }
 // };
 //
 // TEST_P(FlagDependentTest, TestFeature1) {
 //   // Test your code using external_flag_1 and external_flag_2 here.
 // }
-// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
-//                          Combine(Bool(), Bool()));
+// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest, 
+//                          Combine(Bool(), Bool())); 
 //
-template <typename... Generator>
-internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
-  return internal::CartesianProductHolder<Generator...>(g...);
+template <typename... Generator> 
+internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) { 
+  return internal::CartesianProductHolder<Generator...>(g...); 
 }
 
-#define TEST_P(test_suite_name, test_name)                                     \
-  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
-      : public test_suite_name {                                               \
-   public:                                                                     \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
-    void TestBody() override;                                                  \
-                                                                               \
-   private:                                                                    \
-    static int AddToRegistry() {                                               \
-      ::testing::UnitTest::GetInstance()                                       \
-          ->parameterized_test_registry()                                      \
-          .GetTestSuitePatternHolder<test_suite_name>(                         \
-              GTEST_STRINGIFY_(test_suite_name),                               \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
-          ->AddTestPattern(                                                    \
-              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
-              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
-                  test_suite_name, test_name)>(),                              \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
-      return 0;                                                                \
-    }                                                                          \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
-                                                           test_name));        \
-  };                                                                           \
-  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
-                             test_name)::gtest_registering_dummy_ =            \
-      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
-  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
-
-// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
-// generator and an optional function or functor that generates custom test name
-// suffixes based on the test parameters. Such a function or functor should
-// accept one argument of type testing::TestParamInfo<class ParamType>, and
-// return std::string.
+#define TEST_P(test_suite_name, test_name)                                     \ 
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \ 
+      : public test_suite_name {                                               \ 
+   public:                                                                     \ 
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \ 
+    void TestBody() override;                                                  \ 
+                                                                               \ 
+   private:                                                                    \ 
+    static int AddToRegistry() {                                               \ 
+      ::testing::UnitTest::GetInstance()                                       \ 
+          ->parameterized_test_registry()                                      \ 
+          .GetTestSuitePatternHolder<test_suite_name>(                         \ 
+              GTEST_STRINGIFY_(test_suite_name),                               \ 
+              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \ 
+          ->AddTestPattern(                                                    \ 
+              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \ 
+              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \ 
+                  test_suite_name, test_name)>(),                              \ 
+              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \ 
+      return 0;                                                                \ 
+    }                                                                          \ 
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \ 
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \ 
+                                                           test_name));        \ 
+  };                                                                           \ 
+  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \ 
+                             test_name)::gtest_registering_dummy_ =            \ 
+      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \ 
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody() 
+
+// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify 
+// generator and an optional function or functor that generates custom test name 
+// suffixes based on the test parameters. Such a function or functor 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()).
+// returns the value of testing::PrintToString(GetParam()). 
 //
 // Note: test names must be non-empty, unique, and may only contain ASCII
-// alphanumeric characters or underscore. Because PrintToString adds quotes
-// to std::string and C strings, it won't work for these types.
-
-#define GTEST_EXPAND_(arg) arg
-#define GTEST_GET_FIRST_(first, ...) first
-#define GTEST_GET_SECOND_(first, second, ...) second
-
-#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
-  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
-      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
-    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
-  }                                                                           \
-  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
-      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
-    if (::testing::internal::AlwaysFalse()) {                                 \
-      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
-          __VA_ARGS__,                                                        \
-          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
-          DUMMY_PARAM_)));                                                    \
-      auto t = std::make_tuple(__VA_ARGS__);                                  \
-      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
-                    "Too Many Args!");                                        \
-    }                                                                         \
-    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
-        __VA_ARGS__,                                                          \
-        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
-        DUMMY_PARAM_))))(info);                                               \
-  }                                                                           \
-  static int gtest_##prefix##test_suite_name##_dummy_                         \
-      GTEST_ATTRIBUTE_UNUSED_ =                                               \
-          ::testing::UnitTest::GetInstance()                                  \
-              ->parameterized_test_registry()                                 \
-              .GetTestSuitePatternHolder<test_suite_name>(                    \
-                  GTEST_STRINGIFY_(test_suite_name),                          \
-                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
-              ->AddTestSuiteInstantiation(                                    \
-                  GTEST_STRINGIFY_(prefix),                                   \
-                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
-                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
-                  __FILE__, __LINE__)
-
-
-// Allow Marking a Parameterized test class as not needing to be instantiated.
-#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
-  namespace gtest_do_not_use_outside_namespace_scope {}                   \
-  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
-      GTEST_STRINGIFY_(T))
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define INSTANTIATE_TEST_CASE_P                                            \
-  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
-                "");                                                       \
-  INSTANTIATE_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
+// alphanumeric characters or underscore. Because PrintToString adds quotes 
+// to std::string and C strings, it won't work for these types. 
+
+#define GTEST_EXPAND_(arg) arg 
+#define GTEST_GET_FIRST_(first, ...) first 
+#define GTEST_GET_SECOND_(first, second, ...) second 
+
+#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \ 
+  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \ 
+      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \ 
+    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \ 
+  }                                                                           \ 
+  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \ 
+      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \ 
+    if (::testing::internal::AlwaysFalse()) {                                 \ 
+      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \ 
+          __VA_ARGS__,                                                        \ 
+          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \ 
+          DUMMY_PARAM_)));                                                    \ 
+      auto t = std::make_tuple(__VA_ARGS__);                                  \ 
+      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \ 
+                    "Too Many Args!");                                        \ 
+    }                                                                         \ 
+    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \ 
+        __VA_ARGS__,                                                          \ 
+        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \ 
+        DUMMY_PARAM_))))(info);                                               \ 
+  }                                                                           \ 
+  static int gtest_##prefix##test_suite_name##_dummy_                         \ 
+      GTEST_ATTRIBUTE_UNUSED_ =                                               \ 
+          ::testing::UnitTest::GetInstance()                                  \ 
+              ->parameterized_test_registry()                                 \ 
+              .GetTestSuitePatternHolder<test_suite_name>(                    \ 
+                  GTEST_STRINGIFY_(test_suite_name),                          \ 
+                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \ 
+              ->AddTestSuiteInstantiation(                                    \ 
+                  GTEST_STRINGIFY_(prefix),                                   \ 
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \ 
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \ 
+                  __FILE__, __LINE__) 
+ 
+ 
+// Allow Marking a Parameterized test class as not needing to be instantiated. 
+#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \ 
+  namespace gtest_do_not_use_outside_namespace_scope {}                   \ 
+  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \ 
+      GTEST_STRINGIFY_(T)) 
+ 
+// Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+#define INSTANTIATE_TEST_CASE_P                                            \ 
+  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \ 
+                "");                                                       \ 
+  INSTANTIATE_TEST_SUITE_P 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-printers.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-printers.h
index 5a155d2141..625e7e19fe 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-printers.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-printers.h
@@ -27,8 +27,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
-// Google Test - The Google C++ Testing and Mocking Framework
+ 
+// Google Test - The Google C++ Testing and Mocking Framework 
 //
 // This file implements a universal value printer that can print a
 // value of any type T:
@@ -45,10 +45,10 @@
 //   2. operator<<(ostream&, const T&) defined in either foo or the
 //      global namespace.
 //
-// However if T is an STL-style container then it is printed element-wise
-// unless foo::PrintTo(const T&, ostream*) is defined. Note that
-// operator<<() is ignored for container types.
-//
+// However if T is an STL-style container then it is printed element-wise 
+// unless foo::PrintTo(const T&, ostream*) is defined. Note that 
+// operator<<() is ignored for container types. 
+// 
 // If none of the above is defined, it will print the debug string of
 // the value if it is a protocol buffer, or print the raw bytes in the
 // value otherwise.
@@ -95,157 +95,157 @@
 // being defined as many user-defined container types don't have
 // value_type.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 
 
-#include <functional>
-#include <memory>
+#include <functional> 
+#include <memory> 
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
-#include <tuple>
-#include <type_traits>
+#include <tuple> 
+#include <type_traits> 
 #include <utility>
 #include <vector>
-
-#include "gtest/internal/gtest-internal.h"
+ 
+#include "gtest/internal/gtest-internal.h" 
 #include "gtest/internal/gtest-port.h"
 
 namespace testing {
 
-// Definitions in the internal* namespaces are subject to change without notice.
-// DO NOT USE THEM IN USER CODE!
-namespace internal {
-
-template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os);
-
-// Used to print an STL-style container when the user doesn't define
-// a PrintTo() for it.
-struct ContainerPrinter {
-  template <typename T,
-            typename = typename std::enable_if<
-                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
-                !IsRecursiveContainer<T>::value>::type>
-  static void PrintValue(const T& container, std::ostream* os) {
-    const size_t kMaxCount = 32;  // The maximum number of elements to print.
-    *os << '{';
-    size_t count = 0;
-    for (auto&& elem : container) {
-      if (count > 0) {
-        *os << ',';
-        if (count == kMaxCount) {  // Enough has been printed.
-          *os << " ...";
-          break;
-        }
-      }
-      *os << ' ';
-      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
-      // handle `elem` being a native array.
-      internal::UniversalPrint(elem, os);
-      ++count;
-    }
-
-    if (count > 0) {
-      *os << ' ';
-    }
-    *os << '}';
-  }
-};
-
-// Used to print a pointer that is neither a char pointer nor a member
-// pointer, when the user doesn't define PrintTo() for it.  (A member
-// variable pointer or member function pointer doesn't really point to
-// a location in the address space.  Their representation is
-// implementation-defined.  Therefore they will be printed as raw
-// bytes.)
-struct FunctionPointerPrinter {
-  template <typename T, typename = typename std::enable_if<
-                            std::is_function<T>::value>::type>
-  static void PrintValue(T* p, ::std::ostream* os) {
-    if (p == nullptr) {
-      *os << "NULL";
-    } else {
-      // T is a function type, so '*os << p' doesn't do what we want
-      // (it just prints p as bool).  We want to print p as a const
-      // void*.
-      *os << reinterpret_cast<const void*>(p);
-    }
-  }
-};
-
-struct PointerPrinter {
-  template <typename T>
-  static void PrintValue(T* p, ::std::ostream* os) {
-    if (p == nullptr) {
-      *os << "NULL";
-    } else {
-      // T is not a function type.  We just call << to print p,
-      // relying on ADL to pick up user-defined << for their pointer
-      // types, if any.
-      *os << p;
-    }
-  }
+// Definitions in the internal* namespaces are subject to change without notice. 
+// DO NOT USE THEM IN USER CODE! 
+namespace internal { 
+
+template <typename T> 
+void UniversalPrint(const T& value, ::std::ostream* os); 
+
+// Used to print an STL-style container when the user doesn't define 
+// a PrintTo() for it. 
+struct ContainerPrinter { 
+  template <typename T, 
+            typename = typename std::enable_if< 
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) && 
+                !IsRecursiveContainer<T>::value>::type> 
+  static void PrintValue(const T& container, std::ostream* os) { 
+    const size_t kMaxCount = 32;  // The maximum number of elements to print. 
+    *os << '{'; 
+    size_t count = 0; 
+    for (auto&& elem : container) { 
+      if (count > 0) { 
+        *os << ','; 
+        if (count == kMaxCount) {  // Enough has been printed. 
+          *os << " ..."; 
+          break; 
+        } 
+      } 
+      *os << ' '; 
+      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't 
+      // handle `elem` being a native array. 
+      internal::UniversalPrint(elem, os); 
+      ++count; 
+    } 
+ 
+    if (count > 0) { 
+      *os << ' '; 
+    } 
+    *os << '}'; 
+  } 
 };
 
-namespace internal_stream_operator_without_lexical_name_lookup {
-
-// The presence of an operator<< here will terminate lexical scope lookup
-// straight away (even though it cannot be a match because of its argument
-// types). Thus, the two operator<< calls in StreamPrinter will find only ADL
-// candidates.
-struct LookupBlocker {};
-void operator<<(LookupBlocker, LookupBlocker);
-
-struct StreamPrinter {
-  template <typename T,
-            // Don't accept member pointers here. We'd print them via implicit
-            // conversion to bool, which isn't useful.
-            typename = typename std::enable_if<
-                !std::is_member_pointer<T>::value>::type,
-            // Only accept types for which we can find a streaming operator via
-            // ADL (possibly involving implicit conversions).
-            typename = decltype(std::declval<std::ostream&>()
-                                << std::declval<const T&>())>
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    // Call streaming operator found by ADL, possibly with implicit conversions
-    // of the arguments.
-    // lambda w/o captures treats as pointer to function in clang, but does not match trait is_function
-    // when try to print it via operator <<, clang generates warning about cast pointer to function to pointer to object
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmicrosoft-cast"
-#endif
-    *os << value;
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
+// Used to print a pointer that is neither a char pointer nor a member 
+// pointer, when the user doesn't define PrintTo() for it.  (A member 
+// variable pointer or member function pointer doesn't really point to 
+// a location in the address space.  Their representation is 
+// implementation-defined.  Therefore they will be printed as raw 
+// bytes.) 
+struct FunctionPointerPrinter { 
+  template <typename T, typename = typename std::enable_if< 
+                            std::is_function<T>::value>::type> 
+  static void PrintValue(T* p, ::std::ostream* os) { 
+    if (p == nullptr) { 
+      *os << "NULL"; 
+    } else { 
+      // T is a function type, so '*os << p' doesn't do what we want 
+      // (it just prints p as bool).  We want to print p as a const 
+      // void*. 
+      *os << reinterpret_cast<const void*>(p); 
+    } 
   }
 };
 
-}  // namespace internal_stream_operator_without_lexical_name_lookup
-
-struct ProtobufPrinter {
-  // We print a protobuf using its ShortDebugString() when the string
-  // doesn't exceed this many characters; otherwise we print it using
-  // DebugString() for better readability.
-  static const size_t kProtobufOneLinerMaxLength = 50;
-
-  template <typename T,
-            typename = typename std::enable_if<
-                internal::HasDebugStringAndShortDebugString<T>::value>::type>
+struct PointerPrinter { 
+  template <typename T> 
+  static void PrintValue(T* p, ::std::ostream* os) { 
+    if (p == nullptr) { 
+      *os << "NULL"; 
+    } else { 
+      // T is not a function type.  We just call << to print p, 
+      // relying on ADL to pick up user-defined << for their pointer 
+      // types, if any. 
+      *os << p; 
+    } 
+  } 
+}; 
+
+namespace internal_stream_operator_without_lexical_name_lookup { 
+ 
+// The presence of an operator<< here will terminate lexical scope lookup 
+// straight away (even though it cannot be a match because of its argument 
+// types). Thus, the two operator<< calls in StreamPrinter will find only ADL 
+// candidates. 
+struct LookupBlocker {}; 
+void operator<<(LookupBlocker, LookupBlocker); 
+ 
+struct StreamPrinter { 
+  template <typename T, 
+            // Don't accept member pointers here. We'd print them via implicit 
+            // conversion to bool, which isn't useful. 
+            typename = typename std::enable_if< 
+                !std::is_member_pointer<T>::value>::type, 
+            // Only accept types for which we can find a streaming operator via 
+            // ADL (possibly involving implicit conversions). 
+            typename = decltype(std::declval<std::ostream&>() 
+                                << std::declval<const T&>())> 
   static void PrintValue(const T& value, ::std::ostream* os) {
-    std::string pretty_str = value.ShortDebugString();
-    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
-      pretty_str = "\n" + value.DebugString();
-    }
+    // Call streaming operator found by ADL, possibly with implicit conversions 
+    // of the arguments. 
+    // lambda w/o captures treats as pointer to function in clang, but does not match trait is_function 
+    // when try to print it via operator <<, clang generates warning about cast pointer to function to pointer to object 
+#if defined(__clang__) 
+#pragma clang diagnostic push 
+#pragma clang diagnostic ignored "-Wmicrosoft-cast" 
+#endif 
+    *os << value; 
+#if defined(__clang__) 
+#pragma clang diagnostic pop 
+#endif 
+  } 
+}; 
+ 
+}  // namespace internal_stream_operator_without_lexical_name_lookup 
+ 
+struct ProtobufPrinter { 
+  // We print a protobuf using its ShortDebugString() when the string 
+  // doesn't exceed this many characters; otherwise we print it using 
+  // DebugString() for better readability. 
+  static const size_t kProtobufOneLinerMaxLength = 50; 
+ 
+  template <typename T, 
+            typename = typename std::enable_if< 
+                internal::HasDebugStringAndShortDebugString<T>::value>::type> 
+  static void PrintValue(const T& value, ::std::ostream* os) { 
+    std::string pretty_str = value.ShortDebugString(); 
+    if (pretty_str.length() > kProtobufOneLinerMaxLength) { 
+      pretty_str = "\n" + value.DebugString(); 
+    } 
     *os << ("<" + pretty_str + ">");
   }
 };
 
-struct ConvertibleToIntegerPrinter {
+struct ConvertibleToIntegerPrinter { 
   // Since T has no << operator or PrintTo() but can be implicitly
   // converted to BiggestInt, we print it as a BiggestInt.
   //
@@ -253,72 +253,72 @@ struct ConvertibleToIntegerPrinter {
   // case printing it as an integer is the desired behavior.  In case
   // T is not an enum, printing it as an integer is the best we can do
   // given that it has no user-defined printer.
-  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
-    *os << value;
-  }
-};
-
-struct ConvertibleToStringViewPrinter {
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  static void PrintValue(internal::StringView value, ::std::ostream* os) {
-    internal::UniversalPrint(value, os);
-  }
-#endif
-};
-
-
-// Prints the given number of bytes in the given object to the given
-// ostream.
-GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
-                                     size_t count,
-                                     ::std::ostream* os);
-struct RawBytesPrinter {
-  // SFINAE on `sizeof` to make sure we have a complete type.
-  template <typename T, size_t = sizeof(T)>
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    PrintBytesInObjectTo(
-        static_cast<const unsigned char*>(
-            // Load bearing cast to void* to support iOS
-            reinterpret_cast<const void*>(std::addressof(value))),
-        sizeof(value), os);
+  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) { 
+    *os << value; 
   }
 };
 
-struct FallbackPrinter {
-  template <typename T>
-  static void PrintValue(const T&, ::std::ostream* os) {
-    *os << "(incomplete type)";
-  }
-};
-
-// Try every printer in order and return the first one that works.
-template <typename T, typename E, typename Printer, typename... Printers>
-struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
-
-template <typename T, typename Printer, typename... Printers>
-struct FindFirstPrinter<
-    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
-    Printer, Printers...> {
-  using type = Printer;
-};
-
-// Select the best printer in the following order:
-//  - Print containers (they have begin/end/etc).
-//  - Print function pointers.
-//  - Print object pointers.
-//  - Use the stream operator, if available.
-//  - Print protocol buffers.
-//  - Print types convertible to BiggestInt.
-//  - Print types convertible to StringView, if available.
-//  - Fallback to printing the raw bytes of the object.
+struct ConvertibleToStringViewPrinter { 
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+  static void PrintValue(internal::StringView value, ::std::ostream* os) { 
+    internal::UniversalPrint(value, os); 
+  } 
+#endif 
+}; 
+ 
+
+// Prints the given number of bytes in the given object to the given 
+// ostream. 
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, 
+                                     size_t count, 
+                                     ::std::ostream* os); 
+struct RawBytesPrinter { 
+  // SFINAE on `sizeof` to make sure we have a complete type. 
+  template <typename T, size_t = sizeof(T)> 
+  static void PrintValue(const T& value, ::std::ostream* os) { 
+    PrintBytesInObjectTo( 
+        static_cast<const unsigned char*>( 
+            // Load bearing cast to void* to support iOS 
+            reinterpret_cast<const void*>(std::addressof(value))), 
+        sizeof(value), os); 
+  } 
+}; 
+
+struct FallbackPrinter { 
+  template <typename T> 
+  static void PrintValue(const T&, ::std::ostream* os) { 
+    *os << "(incomplete type)"; 
+  } 
+}; 
+ 
+// Try every printer in order and return the first one that works. 
+template <typename T, typename E, typename Printer, typename... Printers> 
+struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {}; 
+
+template <typename T, typename Printer, typename... Printers> 
+struct FindFirstPrinter< 
+    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)), 
+    Printer, Printers...> { 
+  using type = Printer; 
+}; 
+ 
+// Select the best printer in the following order: 
+//  - Print containers (they have begin/end/etc). 
+//  - Print function pointers. 
+//  - Print object pointers. 
+//  - Use the stream operator, if available. 
+//  - Print protocol buffers. 
+//  - Print types convertible to BiggestInt. 
+//  - Print types convertible to StringView, if available. 
+//  - Fallback to printing the raw bytes of the object. 
 template <typename T>
-void PrintWithFallback(const T& value, ::std::ostream* os) {
-  using Printer = typename FindFirstPrinter<
-      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
-      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
-      ProtobufPrinter, ConvertibleToIntegerPrinter,
-      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
-  Printer::PrintValue(value, os);
+void PrintWithFallback(const T& value, ::std::ostream* os) { 
+  using Printer = typename FindFirstPrinter< 
+      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter, 
+      internal_stream_operator_without_lexical_name_lookup::StreamPrinter, 
+      ProtobufPrinter, ConvertibleToIntegerPrinter, 
+      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type; 
+  Printer::PrintValue(value, os); 
 }
 
 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
@@ -369,14 +369,14 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
-#ifdef __cpp_char8_t
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
-#endif
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
-GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
+#ifdef __cpp_char8_t 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t); 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t); 
+#endif 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t); 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t); 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t); 
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t); 
 
 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
 
@@ -395,13 +395,13 @@ GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
 #ifdef __cpp_lib_char8_t
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
-#endif
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
-GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string); 
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string); 
+#endif 
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string); 
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string); 
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string); 
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string); 
 
 #if GTEST_HAS_STD_WSTRING
 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
@@ -447,7 +447,7 @@ class UniversalPrinter;
 // wants).
 template <typename T>
 void PrintTo(const T& value, ::std::ostream* os) {
-  internal::PrintWithFallback(value, os);
+  internal::PrintWithFallback(value, os); 
 }
 
 // The following list of PrintTo() overloads tells
@@ -478,16 +478,16 @@ inline void PrintTo(bool x, ::std::ostream* os) {
 // is implemented as an unsigned type.
 GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
 
-GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
-inline void PrintTo(char16_t c, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<char32_t>(c), os);
-}
-#ifdef __cpp_char8_t
-inline void PrintTo(char8_t c, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<char32_t>(c), os);
-}
-#endif
-
+GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os); 
+inline void PrintTo(char16_t c, ::std::ostream* os) { 
+  PrintTo(ImplicitCast_<char32_t>(c), os); 
+} 
+#ifdef __cpp_char8_t 
+inline void PrintTo(char8_t c, ::std::ostream* os) { 
+  PrintTo(ImplicitCast_<char32_t>(c), os); 
+} 
+#endif 
+ 
 // Overloads for C strings.
 GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
 inline void PrintTo(char* s, ::std::ostream* os) {
@@ -508,23 +508,23 @@ inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
   PrintTo(ImplicitCast_<const void*>(s), os);
 }
-#ifdef __cpp_char8_t
-// Overloads for u8 strings.
-GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os);
-inline void PrintTo(char8_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char8_t*>(s), os);
-}
-#endif
-// Overloads for u16 strings.
-GTEST_API_ void PrintTo(const char16_t* s, ::std::ostream* os);
-inline void PrintTo(char16_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char16_t*>(s), os);
-}
-// Overloads for u32 strings.
-GTEST_API_ void PrintTo(const char32_t* s, ::std::ostream* os);
-inline void PrintTo(char32_t* s, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<const char32_t*>(s), os);
-}
+#ifdef __cpp_char8_t 
+// Overloads for u8 strings. 
+GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os); 
+inline void PrintTo(char8_t* s, ::std::ostream* os) { 
+  PrintTo(ImplicitCast_<const char8_t*>(s), os); 
+} 
+#endif 
+// Overloads for u16 strings. 
+GTEST_API_ void PrintTo(const char16_t* s, ::std::ostream* os); 
+inline void PrintTo(char16_t* s, ::std::ostream* os) { 
+  PrintTo(ImplicitCast_<const char16_t*>(s), os); 
+} 
+// Overloads for u32 strings. 
+GTEST_API_ void PrintTo(const char32_t* s, ::std::ostream* os); 
+inline void PrintTo(char32_t* s, ::std::ostream* os) { 
+  PrintTo(ImplicitCast_<const char32_t*>(s), os); 
+} 
 
 // MSVC can be configured to define wchar_t as a typedef of unsigned
 // short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
@@ -553,33 +553,33 @@ void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
   }
 }
 
-// Overloads for ::std::string.
+// Overloads for ::std::string. 
 GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
   PrintStringTo(s, os);
 }
 
-// Overloads for ::std::u8string
-#ifdef __cpp_char8_t
-GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
-inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
-  PrintU8StringTo(s, os);
-}
-#endif
-
-// Overloads for ::std::u16string
-GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
-inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
-  PrintU16StringTo(s, os);
-}
-
-// Overloads for ::std::u32string
-GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
-inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
-  PrintU32StringTo(s, os);
-}
-
-// Overloads for ::std::wstring.
+// Overloads for ::std::u8string 
+#ifdef __cpp_char8_t 
+GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os); 
+inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) { 
+  PrintU8StringTo(s, os); 
+} 
+#endif 
+ 
+// Overloads for ::std::u16string 
+GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os); 
+inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) { 
+  PrintU16StringTo(s, os); 
+} 
+ 
+// Overloads for ::std::u32string 
+GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os); 
+inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) { 
+  PrintU32StringTo(s, os); 
+} 
+ 
+// Overloads for ::std::wstring. 
 #if GTEST_HAS_STD_WSTRING
 GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
@@ -587,81 +587,81 @@ inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
 }
 #endif  // GTEST_HAS_STD_WSTRING
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-// Overload for internal::StringView.
-inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
-  PrintTo(::std::string(sp), os);
-}
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
-
-template <typename T>
-void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
-  UniversalPrinter<T&>::Print(ref.get(), os);
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+// Overload for internal::StringView. 
+inline void PrintTo(internal::StringView sp, ::std::ostream* os) { 
+  PrintTo(::std::string(sp), os); 
 }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
 
-inline const void* VoidifyPointer(const void* p) { return p; }
-inline const void* VoidifyPointer(volatile const void* p) {
-  return const_cast<const void*>(p);
-}
+inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; } 
 
-template <typename T, typename Ptr>
-void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
-  if (ptr == nullptr) {
-    *os << "(nullptr)";
-  } else {
-    // We can't print the value. Just print the pointer..
-    *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
-  }
-}
-template <typename T, typename Ptr,
-          typename = typename std::enable_if<!std::is_void<T>::value &&
-                                             !std::is_array<T>::value>::type>
-void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
-  if (ptr == nullptr) {
-    *os << "(nullptr)";
-  } else {
-    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
-    UniversalPrinter<T>::Print(*ptr, os);
-    *os << ")";
-  }
+template <typename T> 
+void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) { 
+  UniversalPrinter<T&>::Print(ref.get(), os); 
 }
 
-template <typename T, typename D>
-void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
-  (PrintSmartPointer<T>)(ptr, os, 0);
-}
-
-template <typename T>
-void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
-  (PrintSmartPointer<T>)(ptr, os, 0);
-}
-
-// Helper function for printing a tuple.  T must be instantiated with
-// a tuple type.
-template <typename T>
-void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
-                  ::std::ostream*) {}
-
-template <typename T, size_t I>
-void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
-                  ::std::ostream* os) {
-  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
-  GTEST_INTENTIONAL_CONST_COND_PUSH_()
-  if (I > 1) {
-    GTEST_INTENTIONAL_CONST_COND_POP_()
-    *os << ", ";
-  }
-  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
-      std::get<I - 1>(t), os);
+inline const void* VoidifyPointer(const void* p) { return p; } 
+inline const void* VoidifyPointer(volatile const void* p) { 
+  return const_cast<const void*>(p); 
+} 
+ 
+template <typename T, typename Ptr> 
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) { 
+  if (ptr == nullptr) { 
+    *os << "(nullptr)"; 
+  } else { 
+    // We can't print the value. Just print the pointer.. 
+    *os << "(" << (VoidifyPointer)(ptr.get()) << ")"; 
+  } 
+} 
+template <typename T, typename Ptr, 
+          typename = typename std::enable_if<!std::is_void<T>::value && 
+                                             !std::is_array<T>::value>::type> 
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) { 
+  if (ptr == nullptr) { 
+    *os << "(nullptr)"; 
+  } else { 
+    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = "; 
+    UniversalPrinter<T>::Print(*ptr, os); 
+    *os << ")"; 
+  } 
+} 
+ 
+template <typename T, typename D> 
+void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) { 
+  (PrintSmartPointer<T>)(ptr, os, 0); 
+} 
+ 
+template <typename T> 
+void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) { 
+  (PrintSmartPointer<T>)(ptr, os, 0); 
+} 
+ 
+// Helper function for printing a tuple.  T must be instantiated with 
+// a tuple type. 
+template <typename T> 
+void PrintTupleTo(const T&, std::integral_constant<size_t, 0>, 
+                  ::std::ostream*) {} 
+
+template <typename T, size_t I> 
+void PrintTupleTo(const T& t, std::integral_constant<size_t, I>, 
+                  ::std::ostream* os) { 
+  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os); 
+  GTEST_INTENTIONAL_CONST_COND_PUSH_() 
+  if (I > 1) { 
+    GTEST_INTENTIONAL_CONST_COND_POP_() 
+    *os << ", "; 
+  } 
+  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print( 
+      std::get<I - 1>(t), os); 
 }
 
 template <typename... Types>
 void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
-  *os << "(";
-  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
-  *os << ")";
+  *os << "("; 
+  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os); 
+  *os << ")"; 
 }
 
 // Overload for std::pair.
@@ -703,90 +703,90 @@ class UniversalPrinter {
   GTEST_DISABLE_MSC_WARNINGS_POP_()
 };
 
-// Remove any const-qualifiers before passing a type to UniversalPrinter.
-template <typename T>
-class UniversalPrinter<const T> : public UniversalPrinter<T> {};
-
-#if GTEST_INTERNAL_HAS_ANY
-
-// Printer for std::any / absl::any
-
-template <>
-class UniversalPrinter<Any> {
- public:
-  static void Print(const Any& value, ::std::ostream* os) {
-    if (value.has_value()) {
-      *os << "value of type " << GetTypeName(value);
-    } else {
-      *os << "no value";
-    }
-  }
-
- private:
-  static std::string GetTypeName(const Any& value) {
-#if GTEST_HAS_RTTI
-    return internal::GetTypeName(value.type());
-#else
-    static_cast<void>(value);  // possibly unused
-    return "<unknown_type>";
-#endif  // GTEST_HAS_RTTI
-  }
-};
-
-#endif  // GTEST_INTERNAL_HAS_ANY
-
-#if GTEST_INTERNAL_HAS_OPTIONAL
-
-// Printer for std::optional / absl::optional
-
-template <typename T>
-class UniversalPrinter<Optional<T>> {
- public:
-  static void Print(const Optional<T>& value, ::std::ostream* os) {
-    *os << '(';
-    if (!value) {
-      *os << "nullopt";
-    } else {
-      UniversalPrint(*value, os);
-    }
-    *os << ')';
-  }
-};
-
-#endif  // GTEST_INTERNAL_HAS_OPTIONAL
-
-#if GTEST_INTERNAL_HAS_VARIANT
-
-// Printer for std::variant / absl::variant
-
-template <typename... T>
-class UniversalPrinter<Variant<T...>> {
- public:
-  static void Print(const Variant<T...>& value, ::std::ostream* os) {
-    *os << '(';
-#if GTEST_HAS_ABSL
-    absl::visit(Visitor{os, value.index()}, value);
-#else
-    std::visit(Visitor{os, value.index()}, value);
-#endif  // GTEST_HAS_ABSL
-    *os << ')';
-  }
-
- private:
-  struct Visitor {
-    template <typename U>
-    void operator()(const U& u) const {
-      *os << "'" << GetTypeName<U>() << "(index = " << index
-          << ")' with value ";
-      UniversalPrint(u, os);
-    }
-    ::std::ostream* os;
-    std::size_t index;
-  };
-};
-
-#endif  // GTEST_INTERNAL_HAS_VARIANT
-
+// Remove any const-qualifiers before passing a type to UniversalPrinter. 
+template <typename T> 
+class UniversalPrinter<const T> : public UniversalPrinter<T> {}; 
+ 
+#if GTEST_INTERNAL_HAS_ANY 
+ 
+// Printer for std::any / absl::any 
+ 
+template <> 
+class UniversalPrinter<Any> { 
+ public: 
+  static void Print(const Any& value, ::std::ostream* os) { 
+    if (value.has_value()) { 
+      *os << "value of type " << GetTypeName(value); 
+    } else { 
+      *os << "no value"; 
+    } 
+  } 
+ 
+ private: 
+  static std::string GetTypeName(const Any& value) { 
+#if GTEST_HAS_RTTI 
+    return internal::GetTypeName(value.type()); 
+#else 
+    static_cast<void>(value);  // possibly unused 
+    return "<unknown_type>"; 
+#endif  // GTEST_HAS_RTTI 
+  } 
+}; 
+ 
+#endif  // GTEST_INTERNAL_HAS_ANY 
+ 
+#if GTEST_INTERNAL_HAS_OPTIONAL 
+ 
+// Printer for std::optional / absl::optional 
+ 
+template <typename T> 
+class UniversalPrinter<Optional<T>> { 
+ public: 
+  static void Print(const Optional<T>& value, ::std::ostream* os) { 
+    *os << '('; 
+    if (!value) { 
+      *os << "nullopt"; 
+    } else { 
+      UniversalPrint(*value, os); 
+    } 
+    *os << ')'; 
+  } 
+}; 
+ 
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL 
+ 
+#if GTEST_INTERNAL_HAS_VARIANT 
+ 
+// Printer for std::variant / absl::variant 
+ 
+template <typename... T> 
+class UniversalPrinter<Variant<T...>> { 
+ public: 
+  static void Print(const Variant<T...>& value, ::std::ostream* os) { 
+    *os << '('; 
+#if GTEST_HAS_ABSL 
+    absl::visit(Visitor{os, value.index()}, value); 
+#else 
+    std::visit(Visitor{os, value.index()}, value); 
+#endif  // GTEST_HAS_ABSL 
+    *os << ')'; 
+  } 
+ 
+ private: 
+  struct Visitor { 
+    template <typename U> 
+    void operator()(const U& u) const { 
+      *os << "'" << GetTypeName<U>() << "(index = " << index 
+          << ")' with value "; 
+      UniversalPrint(u, os); 
+    } 
+    ::std::ostream* os; 
+    std::size_t index; 
+  }; 
+}; 
+ 
+#endif  // GTEST_INTERNAL_HAS_VARIANT 
+ 
 // UniversalPrintArray(begin, len, os) prints an array of 'len'
 // elements, starting at address 'begin'.
 template <typename T>
@@ -814,20 +814,20 @@ void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
 GTEST_API_ void UniversalPrintArray(
     const char* begin, size_t len, ::std::ostream* os);
 
-#ifdef __cpp_char8_t
-// This overload prints a (const) char8_t array compactly.
-GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
-                                    ::std::ostream* os);
-#endif
-
-// This overload prints a (const) char16_t array compactly.
-GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
-                                    ::std::ostream* os);
-
-// This overload prints a (const) char32_t array compactly.
-GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
-                                    ::std::ostream* os);
-
+#ifdef __cpp_char8_t 
+// This overload prints a (const) char8_t array compactly. 
+GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len, 
+                                    ::std::ostream* os); 
+#endif 
+ 
+// This overload prints a (const) char16_t array compactly. 
+GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len, 
+                                    ::std::ostream* os); 
+ 
+// This overload prints a (const) char32_t array compactly. 
+GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len, 
+                                    ::std::ostream* os); 
+ 
 // This overload prints a (const) wchar_t array compactly.
 GTEST_API_ void UniversalPrintArray(
     const wchar_t* begin, size_t len, ::std::ostream* os);
@@ -892,70 +892,70 @@ template <>
 class UniversalTersePrinter<const char*> {
  public:
   static void Print(const char* str, ::std::ostream* os) {
-    if (str == nullptr) {
+    if (str == nullptr) { 
       *os << "NULL";
     } else {
-      UniversalPrint(std::string(str), os);
+      UniversalPrint(std::string(str), os); 
     }
   }
 };
 template <>
-class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
-};
-
-#ifdef __cpp_char8_t
-template <>
-class UniversalTersePrinter<const char8_t*> {
+class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> { 
+}; 
+ 
+#ifdef __cpp_char8_t 
+template <> 
+class UniversalTersePrinter<const char8_t*> { 
  public:
-  static void Print(const char8_t* str, ::std::ostream* os) {
-    if (str == nullptr) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::u8string(str), os);
-    }
+  static void Print(const char8_t* str, ::std::ostream* os) { 
+    if (str == nullptr) { 
+      *os << "NULL"; 
+    } else { 
+      UniversalPrint(::std::u8string(str), os); 
+    } 
   }
 };
-template <>
-class UniversalTersePrinter<char8_t*>
-    : public UniversalTersePrinter<const char8_t*> {};
-#endif
-
-template <>
-class UniversalTersePrinter<const char16_t*> {
- public:
-  static void Print(const char16_t* str, ::std::ostream* os) {
-    if (str == nullptr) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::u16string(str), os);
-    }
-  }
-};
-template <>
-class UniversalTersePrinter<char16_t*>
-    : public UniversalTersePrinter<const char16_t*> {};
-
-template <>
-class UniversalTersePrinter<const char32_t*> {
- public:
-  static void Print(const char32_t* str, ::std::ostream* os) {
-    if (str == nullptr) {
-      *os << "NULL";
-    } else {
-      UniversalPrint(::std::u32string(str), os);
-    }
-  }
-};
-template <>
-class UniversalTersePrinter<char32_t*>
-    : public UniversalTersePrinter<const char32_t*> {};
-
+template <> 
+class UniversalTersePrinter<char8_t*> 
+    : public UniversalTersePrinter<const char8_t*> {}; 
+#endif 
+
+template <> 
+class UniversalTersePrinter<const char16_t*> { 
+ public: 
+  static void Print(const char16_t* str, ::std::ostream* os) { 
+    if (str == nullptr) { 
+      *os << "NULL"; 
+    } else { 
+      UniversalPrint(::std::u16string(str), os); 
+    } 
+  } 
+}; 
+template <> 
+class UniversalTersePrinter<char16_t*> 
+    : public UniversalTersePrinter<const char16_t*> {}; 
+ 
+template <> 
+class UniversalTersePrinter<const char32_t*> { 
+ public: 
+  static void Print(const char32_t* str, ::std::ostream* os) { 
+    if (str == nullptr) { 
+      *os << "NULL"; 
+    } else { 
+      UniversalPrint(::std::u32string(str), os); 
+    } 
+  } 
+}; 
+template <> 
+class UniversalTersePrinter<char32_t*> 
+    : public UniversalTersePrinter<const char32_t*> {}; 
+ 
 #if GTEST_HAS_STD_WSTRING
 template <>
 class UniversalTersePrinter<const wchar_t*> {
  public:
   static void Print(const wchar_t* str, ::std::ostream* os) {
-    if (str == nullptr) {
+    if (str == nullptr) { 
       *os << "NULL";
     } else {
       UniversalPrint(::std::wstring(str), os);
@@ -989,22 +989,22 @@ void UniversalPrint(const T& value, ::std::ostream* os) {
   UniversalPrinter<T1>::Print(value, os);
 }
 
-typedef ::std::vector< ::std::string> Strings;
+typedef ::std::vector< ::std::string> Strings; 
 
   // Tersely prints the first N fields of a tuple to a string vector,
   // one element for each field.
 template <typename Tuple>
-void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
-                               Strings*) {}
-template <typename Tuple, size_t I>
-void TersePrintPrefixToStrings(const Tuple& t,
-                               std::integral_constant<size_t, I>,
-                               Strings* strings) {
-  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
-                            strings);
-  ::std::stringstream ss;
-  UniversalTersePrint(std::get<I - 1>(t), &ss);
-  strings->push_back(ss.str());
+void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>, 
+                               Strings*) {} 
+template <typename Tuple, size_t I> 
+void TersePrintPrefixToStrings(const Tuple& t, 
+                               std::integral_constant<size_t, I>, 
+                               Strings* strings) { 
+  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(), 
+                            strings); 
+  ::std::stringstream ss; 
+  UniversalTersePrint(std::get<I - 1>(t), &ss); 
+  strings->push_back(ss.str()); 
 }
 
 // Prints the fields of a tuple tersely to a string vector, one
@@ -1013,9 +1013,9 @@ void TersePrintPrefixToStrings(const Tuple& t,
 template <typename Tuple>
 Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
   Strings result;
-  TersePrintPrefixToStrings(
-      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
-      &result);
+  TersePrintPrefixToStrings( 
+      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(), 
+      &result); 
   return result;
 }
 
@@ -1035,4 +1035,4 @@ template <typename T>
 // declarations from this file.
 #include "gtest/internal/custom/gtest-printers.h"
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-spi.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-spi.h
index eacef44669..142e50634a 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-spi.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-spi.h
@@ -26,21 +26,21 @@
 // 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.
-
+ 
 //
 // Utilities for testing Google Test itself and code that uses Google Test
 // (e.g. frameworks built on top of Google Test).
 
-// GOOGLETEST_CM0004 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+// GOOGLETEST_CM0004 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ 
 
 #include "gtest/gtest.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 
 // This helper class can be used to mock out Google Test failure reporting
@@ -72,15 +72,15 @@ class GTEST_API_ ScopedFakeTestPartResultReporter
                                    TestPartResultArray* result);
 
   // The d'tor restores the previous test part result reporter.
-  ~ScopedFakeTestPartResultReporter() override;
+  ~ScopedFakeTestPartResultReporter() override; 
 
   // Appends the TestPartResult object to the TestPartResultArray
   // received in the constructor.
   //
   // This method is from the TestPartResultReporterInterface
   // interface.
-  void ReportTestPartResult(const TestPartResult& result) override;
-
+  void ReportTestPartResult(const TestPartResult& result) override; 
+ 
  private:
   void Init();
 
@@ -102,12 +102,12 @@ class GTEST_API_ SingleFailureChecker {
  public:
   // The constructor remembers the arguments.
   SingleFailureChecker(const TestPartResultArray* results,
-                       TestPartResult::Type type, const std::string& substr);
+                       TestPartResult::Type type, const std::string& substr); 
   ~SingleFailureChecker();
  private:
   const TestPartResultArray* const results_;
   const TestPartResult::Type type_;
-  const std::string substr_;
+  const std::string substr_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
 };
@@ -116,8 +116,8 @@ class GTEST_API_ SingleFailureChecker {
 
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
 // A set of macros for testing Google Test assertions or code that's expected
 // to generate Google Test fatal failures.  It verifies that the given
 // statement will cause exactly one fatal Google Test failure with 'substr'
@@ -235,4 +235,4 @@ GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
     }\
   } while (::testing::internal::AlwaysFalse())
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-test-part.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-test-part.h
index 203fdf98c6..5092f872ca 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-test-part.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-test-part.h
@@ -27,19 +27,19 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// GOOGLETEST_CM0001 DO NOT DELETE
+// GOOGLETEST_CM0001 DO NOT DELETE 
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ 
 
 #include <iosfwd>
 #include <vector>
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 
 // A copyable object representing the result of a test part (i.e. an
@@ -53,20 +53,20 @@ class GTEST_API_ TestPartResult {
   enum Type {
     kSuccess,          // Succeeded.
     kNonFatalFailure,  // Failed but the test can continue.
-    kFatalFailure,     // Failed and the test should be terminated.
-    kSkip              // Skipped.
+    kFatalFailure,     // Failed and the test should be terminated. 
+    kSkip              // Skipped. 
   };
 
   // C'tor.  TestPartResult does NOT have a default constructor.
   // Always use this constructor (with parameters) to create a
   // TestPartResult object.
-  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
+  TestPartResult(Type a_type, const char* a_file_name, int a_line_number, 
                  const char* a_message)
       : type_(a_type),
-        file_name_(a_file_name == nullptr ? "" : a_file_name),
+        file_name_(a_file_name == nullptr ? "" : a_file_name), 
         line_number_(a_line_number),
         summary_(ExtractSummary(a_message)),
-        message_(a_message) {}
+        message_(a_message) {} 
 
   // Gets the outcome of the test part.
   Type type() const { return type_; }
@@ -74,7 +74,7 @@ class GTEST_API_ TestPartResult {
   // Gets the name of the source file where the test part took place, or
   // NULL if it's unknown.
   const char* file_name() const {
-    return file_name_.empty() ? nullptr : file_name_.c_str();
+    return file_name_.empty() ? nullptr : file_name_.c_str(); 
   }
 
   // Gets the line in the source file where the test part took place,
@@ -87,21 +87,21 @@ class GTEST_API_ TestPartResult {
   // Gets the message associated with the test part.
   const char* message() const { return message_.c_str(); }
 
-  // Returns true if and only if the test part was skipped.
-  bool skipped() const { return type_ == kSkip; }
-
-  // Returns true if and only if the test part passed.
+  // Returns true if and only if the test part was skipped. 
+  bool skipped() const { return type_ == kSkip; } 
+ 
+  // Returns true if and only if the test part passed. 
   bool passed() const { return type_ == kSuccess; }
 
-  // Returns true if and only if the test part non-fatally failed.
+  // Returns true if and only if the test part non-fatally failed. 
   bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
 
-  // Returns true if and only if the test part fatally failed.
+  // Returns true if and only if the test part fatally failed. 
   bool fatally_failed() const { return type_ == kFatalFailure; }
 
-  // Returns true if and only if the test part failed.
-  bool failed() const { return fatally_failed() || nonfatally_failed(); }
-
+  // Returns true if and only if the test part failed. 
+  bool failed() const { return fatally_failed() || nonfatally_failed(); } 
+ 
  private:
   Type type_;
 
@@ -146,7 +146,7 @@ class GTEST_API_ TestPartResultArray {
 };
 
 // This interface knows how to report a test part result.
-class GTEST_API_ TestPartResultReporterInterface {
+class GTEST_API_ TestPartResultReporterInterface { 
  public:
   virtual ~TestPartResultReporterInterface() {}
 
@@ -165,8 +165,8 @@ class GTEST_API_ HasNewFatalFailureHelper
     : public TestPartResultReporterInterface {
  public:
   HasNewFatalFailureHelper();
-  ~HasNewFatalFailureHelper() override;
-  void ReportTestPartResult(const TestPartResult& result) override;
+  ~HasNewFatalFailureHelper() override; 
+  void ReportTestPartResult(const TestPartResult& result) override; 
   bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
  private:
   bool has_new_fatal_failure_;
@@ -179,6 +179,6 @@ class GTEST_API_ HasNewFatalFailureHelper
 
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest-typed-test.h b/contrib/restricted/googletest/googletest/include/gtest/gtest-typed-test.h
index 9fdc6be10d..3fc71eea41 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest-typed-test.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest-typed-test.h
@@ -27,10 +27,10 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ 
 
 // This header implements typed tests and type-parameterized tests.
 
@@ -51,22 +51,22 @@ class FooTest : public testing::Test {
   T value_;
 };
 
-// Next, associate a list of types with the test suite, which will be
+// Next, associate a list of types with the test suite, which will be 
 // repeated for each type in the list.  The typedef is necessary for
 // the macro to parse correctly.
 typedef testing::Types<char, int, unsigned int> MyTypes;
-TYPED_TEST_SUITE(FooTest, MyTypes);
+TYPED_TEST_SUITE(FooTest, MyTypes); 
 
 // If the type list contains only one type, you can write that type
 // directly without Types<...>:
-//   TYPED_TEST_SUITE(FooTest, int);
+//   TYPED_TEST_SUITE(FooTest, int); 
 
 // Then, use TYPED_TEST() instead of TEST_F() to define as many typed
-// tests for this test suite as you want.
+// tests for this test suite as you want. 
 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'.
+  // 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::
@@ -82,24 +82,24 @@ TYPED_TEST(FooTest, DoesBlah) {
 
 TYPED_TEST(FooTest, HasPropertyA) { ... }
 
-// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
-// class that generates custom test name suffixes based on the type. This should
-// be a class which has a static template function GetName(int index) returning
-// a string for each type. The provided integer index equals the index of the
-// type in the provided type list. In many cases the index can be ignored.
-//
-// For example:
-//   class MyTypeNames {
-//    public:
-//     template <typename T>
-//     static std::string GetName(int) {
-//       if (std::is_same<T, char>()) return "char";
-//       if (std::is_same<T, int>()) return "int";
-//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
-//     }
-//   };
-//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
-
+// TYPED_TEST_SUITE takes an optional third argument which allows to specify a 
+// class that generates custom test name suffixes based on the type. This should 
+// be a class which has a static template function GetName(int index) returning 
+// a string for each type. The provided integer index equals the index of the 
+// type in the provided type list. In many cases the index can be ignored. 
+// 
+// For example: 
+//   class MyTypeNames { 
+//    public: 
+//     template <typename T> 
+//     static std::string GetName(int) { 
+//       if (std::is_same<T, char>()) return "char"; 
+//       if (std::is_same<T, int>()) return "int"; 
+//       if (std::is_same<T, unsigned int>()) return "unsignedInt"; 
+//     } 
+//   }; 
+//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames); 
+ 
 #endif  // 0
 
 // Type-parameterized tests are abstract test patterns parameterized
@@ -125,13 +125,13 @@ class FooTest : public testing::Test {
   ...
 };
 
-// Next, declare that you will define a type-parameterized test suite
+// Next, declare that you will define a type-parameterized test suite 
 // (the _P suffix is for "parameterized" or "pattern", whichever you
 // prefer):
-TYPED_TEST_SUITE_P(FooTest);
+TYPED_TEST_SUITE_P(FooTest); 
 
 // Then, use TYPED_TEST_P() to define as many type-parameterized tests
-// for this type-parameterized test suite as you want.
+// for this type-parameterized test suite as you want. 
 TYPED_TEST_P(FooTest, DoesBlah) {
   // Inside a test, refer to TypeParam to get the type parameter.
   TypeParam n = 0;
@@ -142,10 +142,10 @@ TYPED_TEST_P(FooTest, HasPropertyA) { ... }
 
 // Now the tricky part: you need to register all test patterns 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
+// test suite name; the rest are the names of the tests in this test 
 // case.
-REGISTER_TYPED_TEST_SUITE_P(FooTest,
-                            DoesBlah, HasPropertyA);
+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
@@ -153,23 +153,23 @@ REGISTER_TYPED_TEST_SUITE_P(FooTest,
 //
 // To distinguish different instances of the pattern, the first
 // argument to the INSTANTIATE_* macro is a prefix that will be added
-// to the actual test suite name.  Remember to pick unique prefixes for
+// to the actual test suite name.  Remember to pick unique prefixes for 
 // different instances.
 typedef testing::Types<char, int, unsigned int> MyTypes;
-INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); 
 
 // If the type list contains only one type, you can write that type
 // directly without Types<...>:
-//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
-//
-// Similar to the optional argument of TYPED_TEST_SUITE above,
-// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
-// generate custom names.
-//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int); 
+// 
+// Similar to the optional argument of TYPED_TEST_SUITE above, 
+// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to 
+// generate custom names. 
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames); 
 
 #endif  // 0
 
-#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-internal.h" 
 #include "gtest/internal/gtest-port.h"
 #include "gtest/internal/gtest-type-util.h"
 
@@ -178,152 +178,152 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // Expands to the name of the typedef for the type parameters of the
-// given test suite.
-#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_
-
-// Expands to the name of the typedef for the NameGenerator, responsible for
-// creating the suffixes of the name.
-#define GTEST_NAME_GENERATOR_(TestSuiteName) \
-  gtest_type_params_##TestSuiteName##_NameGenerator
-
-#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \
-  typedef ::testing::internal::GenerateTypeList<Types>::type            \
-      GTEST_TYPE_PARAMS_(CaseName);                                     \
-  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
-      GTEST_NAME_GENERATOR_(CaseName)
-
-#define TYPED_TEST(CaseName, TestName)                                        \
-  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
-                "test-name must not be empty");                               \
-  template <typename gtest_TypeParam_>                                        \
-  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
-      : public CaseName<gtest_TypeParam_> {                                   \
-   private:                                                                   \
-    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
-    typedef gtest_TypeParam_ TypeParam;                                       \
-    void TestBody() override;                                                 \
-  };                                                                          \
-  static bool gtest_##CaseName##_##TestName##_registered_                     \
-      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
-          CaseName,                                                           \
-          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
-                                                                  TestName)>, \
-          GTEST_TYPE_PARAMS_(                                                 \
-              CaseName)>::Register("",                                        \
-                                   ::testing::internal::CodeLocation(         \
-                                       __FILE__, __LINE__),                   \
-                                   GTEST_STRINGIFY_(CaseName),                \
-                                   GTEST_STRINGIFY_(TestName), 0,             \
-                                   ::testing::internal::GenerateNames<        \
-                                       GTEST_NAME_GENERATOR_(CaseName),       \
-                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
-  template <typename gtest_TypeParam_>                                        \
-  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
-                              TestName)<gtest_TypeParam_>::TestBody()
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define TYPED_TEST_CASE                                                \
-  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
-  TYPED_TEST_SUITE
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
+// given test suite. 
+#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_ 
+
+// Expands to the name of the typedef for the NameGenerator, responsible for 
+// creating the suffixes of the name. 
+#define GTEST_NAME_GENERATOR_(TestSuiteName) \ 
+  gtest_type_params_##TestSuiteName##_NameGenerator 
+
+#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \ 
+  typedef ::testing::internal::GenerateTypeList<Types>::type            \ 
+      GTEST_TYPE_PARAMS_(CaseName);                                     \ 
+  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \ 
+      GTEST_NAME_GENERATOR_(CaseName) 
+
+#define TYPED_TEST(CaseName, TestName)                                        \ 
+  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \ 
+                "test-name must not be empty");                               \ 
+  template <typename gtest_TypeParam_>                                        \ 
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \ 
+      : public CaseName<gtest_TypeParam_> {                                   \ 
+   private:                                                                   \ 
+    typedef CaseName<gtest_TypeParam_> TestFixture;                           \ 
+    typedef gtest_TypeParam_ TypeParam;                                       \ 
+    void TestBody() override;                                                 \ 
+  };                                                                          \ 
+  static bool gtest_##CaseName##_##TestName##_registered_                     \ 
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \ 
+          CaseName,                                                           \ 
+          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \ 
+                                                                  TestName)>, \ 
+          GTEST_TYPE_PARAMS_(                                                 \ 
+              CaseName)>::Register("",                                        \ 
+                                   ::testing::internal::CodeLocation(         \ 
+                                       __FILE__, __LINE__),                   \ 
+                                   GTEST_STRINGIFY_(CaseName),                \ 
+                                   GTEST_STRINGIFY_(TestName), 0,             \ 
+                                   ::testing::internal::GenerateNames<        \ 
+                                       GTEST_NAME_GENERATOR_(CaseName),       \ 
+                                       GTEST_TYPE_PARAMS_(CaseName)>());      \ 
+  template <typename gtest_TypeParam_>                                        \ 
+  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \ 
+                              TestName)<gtest_TypeParam_>::TestBody() 
+ 
+// Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+#define TYPED_TEST_CASE                                                \ 
+  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \ 
+  TYPED_TEST_SUITE 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
 // Implements type-parameterized tests.
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // Expands to the namespace name that the type-parameterized tests for
-// the given type-parameterized test suite are defined in.  The exact
+// the given type-parameterized test suite are defined in.  The exact 
 // name of the namespace is subject to change without notice.
-#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_
+#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_ 
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // Expands to the name of the variable used to remember the names of
-// the defined tests in the given test suite.
-#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
-  gtest_typed_test_suite_p_state_##TestSuiteName##_
+// the defined tests in the given test suite. 
+#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \ 
+  gtest_typed_test_suite_p_state_##TestSuiteName##_ 
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
 //
 // Expands to the name of the variable used to remember the names of
-// the registered tests in the given test suite.
-#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
-  gtest_registered_test_names_##TestSuiteName##_
+// the registered tests in the given test suite. 
+#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \ 
+  gtest_registered_test_names_##TestSuiteName##_ 
 
 // The variables defined in the type-parameterized test macros are
 // static as typically these macros are used in a .h file that can be
 // #included in multiple translation units linked together.
-#define TYPED_TEST_SUITE_P(SuiteName)              \
-  static ::testing::internal::TypedTestSuitePState \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define TYPED_TEST_CASE_P                                                 \
-  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
-  TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#define TYPED_TEST_P(SuiteName, TestName)                             \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \
-    template <typename gtest_TypeParam_>                              \
-    class TestName : public SuiteName<gtest_TypeParam_> {             \
-     private:                                                         \
-      typedef SuiteName<gtest_TypeParam_> TestFixture;                \
-      typedef gtest_TypeParam_ TypeParam;                             \
-      void TestBody() override;                                       \
-    };                                                                \
-    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
-        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
-            __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
-            GTEST_STRINGIFY_(TestName));                              \
-  }                                                                   \
-  template <typename gtest_TypeParam_>                                \
-  void GTEST_SUITE_NAMESPACE_(                                        \
-      SuiteName)::TestName<gtest_TypeParam_>::TestBody()
-
-// Note: this won't work correctly if the trailing arguments are macros.
-#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
-    typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;    \
-  }                                                                         \
-  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
-      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
-          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define REGISTER_TYPED_TEST_CASE_P                                           \
-  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
-                "");                                                         \
-  REGISTER_TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
-  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \
-                "test-suit-prefix must not be empty");                      \
-  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
-      ::testing::internal::TypeParameterizedTestSuite<                      \
-          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
-          ::testing::internal::GenerateTypeList<Types>::type>::             \
-          Register(GTEST_STRINGIFY_(Prefix),                                \
-                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
-                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
-                   GTEST_STRINGIFY_(SuiteName),                             \
-                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
-                   ::testing::internal::GenerateNames<                      \
-                       ::testing::internal::NameGeneratorSelector<          \
-                           __VA_ARGS__>::type,                              \
-                       ::testing::internal::GenerateTypeList<Types>::type>())
-
-// Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
-  static_assert(                                                           \
-      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
-  INSTANTIATE_TYPED_TEST_SUITE_P
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define TYPED_TEST_SUITE_P(SuiteName)              \ 
+  static ::testing::internal::TypedTestSuitePState \ 
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName) 
+
+// Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+#define TYPED_TEST_CASE_P                                                 \ 
+  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \ 
+  TYPED_TEST_SUITE_P 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+
+#define TYPED_TEST_P(SuiteName, TestName)                             \ 
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \ 
+    template <typename gtest_TypeParam_>                              \ 
+    class TestName : public SuiteName<gtest_TypeParam_> {             \ 
+     private:                                                         \ 
+      typedef SuiteName<gtest_TypeParam_> TestFixture;                \ 
+      typedef gtest_TypeParam_ TypeParam;                             \ 
+      void TestBody() override;                                       \ 
+    };                                                                \ 
+    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ 
+        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \ 
+            __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \ 
+            GTEST_STRINGIFY_(TestName));                              \ 
+  }                                                                   \ 
+  template <typename gtest_TypeParam_>                                \ 
+  void GTEST_SUITE_NAMESPACE_(                                        \ 
+      SuiteName)::TestName<gtest_TypeParam_>::TestBody() 
+ 
+// Note: this won't work correctly if the trailing arguments are macros. 
+#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \ 
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \ 
+    typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;    \ 
+  }                                                                         \ 
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \ 
+      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \ 
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \ 
+          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__) 
+
+// Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+#define REGISTER_TYPED_TEST_CASE_P                                           \ 
+  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \ 
+                "");                                                         \ 
+  REGISTER_TYPED_TEST_SUITE_P 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+
+#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \ 
+  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \ 
+                "test-suit-prefix must not be empty");                      \ 
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \ 
+      ::testing::internal::TypeParameterizedTestSuite<                      \ 
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \ 
+          ::testing::internal::GenerateTypeList<Types>::type>::             \ 
+          Register(GTEST_STRINGIFY_(Prefix),                                \ 
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \ 
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \ 
+                   GTEST_STRINGIFY_(SuiteName),                             \ 
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \ 
+                   ::testing::internal::GenerateNames<                      \ 
+                       ::testing::internal::NameGeneratorSelector<          \ 
+                           __VA_ARGS__>::type,                              \ 
+                       ::testing::internal::GenerateTypeList<Types>::type>()) 
+ 
+// Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+#define INSTANTIATE_TYPED_TEST_CASE_P                                      \ 
+  static_assert(                                                           \ 
+      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \ 
+  INSTANTIATE_TYPED_TEST_SUITE_P 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest.h b/contrib/restricted/googletest/googletest/include/gtest/gtest.h
index 7a5d057c4a..7906d5b4a7 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest.h
@@ -26,9 +26,9 @@
 // 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)
+// 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.
@@ -47,22 +47,22 @@
 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
 // easyUnit framework.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_ 
 
-#include <cstddef>
+#include <cstddef> 
 #include <limits>
-#include <memory>
+#include <memory> 
 #include <ostream>
-#include <type_traits>
+#include <type_traits> 
 #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-matchers.h" 
 #include "gtest/gtest-message.h"
 #include "gtest/gtest-param-test.h"
 #include "gtest/gtest-printers.h"
@@ -70,20 +70,20 @@
 #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 */)
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
 
 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
-
-
+// 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.
@@ -101,18 +101,18 @@ GTEST_DECLARE_bool_(catch_exceptions);
 // to let Google Test decide.
 GTEST_DECLARE_string_(color);
 
-// This flag controls whether the test runner should continue execution past
-// first failure.
-GTEST_DECLARE_bool_(fail_fast);
-
+// This flag controls whether the test runner should continue execution past 
+// first failure. 
+GTEST_DECLARE_bool_(fail_fast); 
+ 
 // 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 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);
@@ -121,16 +121,16 @@ GTEST_DECLARE_bool_(list_tests);
 // in addition to its normal textual output.
 GTEST_DECLARE_string_(output);
 
-// This flags control whether Google Test prints only test failures.
-GTEST_DECLARE_bool_(brief);
-
+// This flags control whether Google Test prints only test failures. 
+GTEST_DECLARE_bool_(brief); 
+ 
 // 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 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);
 
@@ -151,7 +151,7 @@ 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.
+// 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
@@ -159,10 +159,10 @@ GTEST_DECLARE_bool_(throw_on_failure);
 // 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_
-
+#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;
 
@@ -180,11 +180,11 @@ class TestEventListenersAccessor;
 class TestEventRepeater;
 class UnitTestRecordPropertyTestHelper;
 class WindowsDeathTest;
-class FuchsiaDeathTest;
+class FuchsiaDeathTest; 
 class UnitTestImpl* GetUnitTestImpl();
 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
                                     const std::string& message);
-std::set<std::string>* GetIgnoredParameterizedTestSuites();
+std::set<std::string>* GetIgnoredParameterizedTestSuites(); 
 
 }  // namespace internal
 
@@ -192,12 +192,12 @@ std::set<std::string>* GetIgnoredParameterizedTestSuites();
 // 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 TestSuite; 
+ 
+// Old API is still available but deprecated 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+using TestCase = TestSuite; 
+#endif 
 class TestInfo;
 class UnitTest;
 
@@ -286,13 +286,13 @@ class GTEST_API_ AssertionResult {
   // Used in EXPECT_TRUE/FALSE(assertion_result).
   AssertionResult(const AssertionResult& other);
 
-// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
-// This warning is not emitted in Visual Studio 2017.
-// This warning is off by default starting in Visual Studio 2019 but can be
-// enabled with command-line options.
-#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+// C4800 is a level 3 warning in Visual Studio 2015 and earlier. 
+// This warning is not emitted in Visual Studio 2017. 
+// This warning is off by default starting in Visual Studio 2019 but can be 
+// enabled with command-line options. 
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920) 
   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
-#endif
+#endif 
 
   // Used in the EXPECT_TRUE/FALSE(bool_expression).
   //
@@ -304,15 +304,15 @@ class GTEST_API_ AssertionResult {
   template <typename T>
   explicit AssertionResult(
       const T& success,
-      typename std::enable_if<
-          !std::is_convertible<T, AssertionResult>::value>::type*
-      /*enabler*/
-      = nullptr)
+      typename std::enable_if< 
+          !std::is_convertible<T, AssertionResult>::value>::type* 
+      /*enabler*/ 
+      = nullptr) 
       : success_(success) {}
 
-#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920) 
   GTEST_DISABLE_MSC_WARNINGS_POP_()
-#endif
+#endif 
 
   // Assignment operator.
   AssertionResult& operator=(AssertionResult other) {
@@ -320,7 +320,7 @@ class GTEST_API_ AssertionResult {
     return *this;
   }
 
-  // Returns true if and only if the assertion succeeded.
+  // Returns true if and only if the assertion succeeded. 
   operator bool() const { return success_; }  // NOLINT
 
   // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
@@ -331,7 +331,7 @@ class GTEST_API_ AssertionResult {
   // 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() : "";
+    return message_.get() != nullptr ? message_->c_str() : ""; 
   }
   // Deprecated; please use message() instead.
   const char* failure_message() const { return message(); }
@@ -353,7 +353,7 @@ class GTEST_API_ AssertionResult {
  private:
   // Appends the contents of message to message_.
   void AppendMessage(const Message& a_message) {
-    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    if (message_.get() == nullptr) message_.reset(new ::std::string); 
     message_->append(a_message.GetString().c_str());
   }
 
@@ -366,7 +366,7 @@ class GTEST_API_ AssertionResult {
   // 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_;
+  std::unique_ptr< ::std::string> message_; 
 };
 
 // Makes a successful assertion result.
@@ -379,26 +379,26 @@ GTEST_API_ AssertionResult AssertionFailure();
 // 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 {
-
+}  // 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.
+// 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:
+// to be used in a TEST_F.  For example: 
 //
 //   class FooTest : public testing::Test {
 //    protected:
@@ -418,51 +418,51 @@ class GTEST_API_ Test {
   // 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 suite.
+  // Sets up the stuff shared by all tests in this test suite. 
   //
-  // Google Test will call Foo::SetUpTestSuite() before running the first
-  // test in test suite Foo.  Hence a sub-class can define its own
-  // SetUpTestSuite() method to shadow the one defined in the super
+  // Google Test will call Foo::SetUpTestSuite() before running the first 
+  // test in test suite Foo.  Hence a sub-class can define its own 
+  // SetUpTestSuite() method to shadow the one defined in the super 
   // class.
-  static void SetUpTestSuite() {}
+  static void SetUpTestSuite() {} 
 
-  // Tears down the stuff shared by all tests in this test suite.
+  // Tears down the stuff shared by all tests in this test suite. 
   //
-  // Google Test will call Foo::TearDownTestSuite() after running the last
-  // test in test suite Foo.  Hence a sub-class can define its own
-  // TearDownTestSuite() method to shadow the one defined in the super
+  // Google Test will call Foo::TearDownTestSuite() after running the last 
+  // test in test suite 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. Use SetUpTestSuite and
-  // TearDownTestSuite instead.
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  static void TearDownTestSuite() {} 
+ 
+  // Legacy API is deprecated but still available. Use SetUpTestSuite and 
+  // TearDownTestSuite instead. 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
   static void TearDownTestCase() {}
-  static void SetUpTestCase() {}
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  static void SetUpTestCase() {} 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 
-  // Returns true if and only if the current test has a fatal failure.
+  // Returns true if and only if the current test has a fatal failure. 
   static bool HasFatalFailure();
 
-  // Returns true if and only if the current test has a non-fatal failure.
+  // Returns true if and only if the current test has a non-fatal failure. 
   static bool HasNonfatalFailure();
 
-  // Returns true if and only if the current test was skipped.
-  static bool IsSkipped();
-
-  // Returns true if and only if the current test has a (either fatal or
+  // Returns true if and only if the current test was skipped. 
+  static bool IsSkipped(); 
+ 
+  // Returns true if and only if 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
+  // 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
+  // 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
+  // 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
@@ -481,8 +481,8 @@ class GTEST_API_ Test {
   virtual void TearDown();
 
  private:
-  // Returns true if and only if the current test has the same fixture class
-  // as the first test in the current test suite.
+  // Returns true if and only if 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.
@@ -500,7 +500,7 @@ class GTEST_API_ Test {
   // 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_;
+  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
@@ -519,7 +519,7 @@ class GTEST_API_ Test {
   // 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; }
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; } 
 
   // We disallow copying Tests.
   GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
@@ -583,30 +583,30 @@ class GTEST_API_ TestResult {
   // Returns the number of the test properties.
   int test_property_count() const;
 
-  // Returns true if and only if the test passed (i.e. no test part failed).
-  bool Passed() const { return !Skipped() && !Failed(); }
-
-  // Returns true if and only if the test was skipped.
-  bool Skipped() const;
+  // Returns true if and only if the test passed (i.e. no test part failed). 
+  bool Passed() const { return !Skipped() && !Failed(); } 
 
-  // Returns true if and only if the test failed.
+  // Returns true if and only if the test was skipped. 
+  bool Skipped() const; 
+ 
+  // Returns true if and only if the test failed. 
   bool Failed() const;
 
-  // Returns true if and only if the test fatally failed.
+  // Returns true if and only if the test fatally failed. 
   bool HasFatalFailure() const;
 
-  // Returns true if and only if the test has a non-fatal failure.
+  // Returns true if and only if the test has a non-fatal failure. 
   bool HasNonfatalFailure() const;
 
   // Returns the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
-  // Gets the time of the test case start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const { return start_timestamp_; }
-
-  // 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.
+  // Gets the time of the test case start, in ms from the start of the 
+  // UNIX epoch. 
+  TimeInMillis start_timestamp() const { return start_timestamp_; } 
+ 
+  // 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
@@ -616,14 +616,14 @@ class GTEST_API_ TestResult {
 
  private:
   friend class TestInfo;
-  friend class TestSuite;
+  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;
+  friend class internal::FuchsiaDeathTest; 
 
   // Gets the vector of TestPartResults.
   const std::vector<TestPartResult>& test_part_results() const {
@@ -635,9 +635,9 @@ class GTEST_API_ TestResult {
     return test_properties_;
   }
 
-  // Sets the start time.
-  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
-
+  // Sets the start time. 
+  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; } 
+ 
   // Sets the elapsed time.
   void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
 
@@ -651,8 +651,8 @@ class GTEST_API_ TestResult {
                       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.
+  // 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);
 
@@ -673,7 +673,7 @@ class GTEST_API_ TestResult {
 
   // Protects mutable state of the property vector and of owned
   // properties, whose values may be updated.
-  internal::Mutex test_properties_mutex_;
+  internal::Mutex test_properties_mutex_; 
 
   // The vector of TestPartResults
   std::vector<TestPartResult> test_part_results_;
@@ -681,8 +681,8 @@ class GTEST_API_ TestResult {
   std::vector<TestProperty> test_properties_;
   // Running count of death tests.
   int death_test_count_;
-  // The start time, in milliseconds since UNIX Epoch.
-  TimeInMillis start_timestamp_;
+  // The start time, in milliseconds since UNIX Epoch. 
+  TimeInMillis start_timestamp_; 
   // The elapsed time, in milliseconds.
   TimeInMillis elapsed_time_;
 
@@ -692,7 +692,7 @@ class GTEST_API_ TestResult {
 
 // A TestInfo object stores the following information about a test:
 //
-//   Test suite name
+//   Test suite name 
 //   Test name
 //   Whether the test should be run
 //   A function pointer that creates the test object when invoked
@@ -707,29 +707,29 @@ class GTEST_API_ TestInfo {
   // 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 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;
+    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;
+    if (value_param_.get() != nullptr) return value_param_->c_str(); 
+    return nullptr; 
   }
 
   // Returns the file name where this test is defined.
@@ -738,15 +738,15 @@ class GTEST_API_ TestInfo {
   // 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_; }
-
+  // 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
+  // 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,
@@ -759,11 +759,11 @@ class GTEST_API_ TestInfo {
   // contains the character 'A' or starts with "Foo.".
   bool should_run() const { return should_run_; }
 
-  // Returns true if and only if this test will appear in the XML report.
+  // Returns true if and only if 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_;
+    // 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.
@@ -774,19 +774,19 @@ class GTEST_API_ TestInfo {
   friend class internal::DefaultDeathTestFactory;
 #endif  // GTEST_HAS_DEATH_TEST
   friend class Test;
-  friend class TestSuite;
+  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,
+      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,
+  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,
@@ -803,29 +803,29 @@ class GTEST_API_ TestInfo {
   // deletes it.
   void Run();
 
-  // Skip and records the test result for this object.
-  void Skip();
-
+  // Skip and records the test result for this object. 
+  void Skip(); 
+ 
   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 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_;
+  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_;
+  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 if and only if this test should run
-  bool is_disabled_;          // True if and only if 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.
+  const internal::TypeId fixture_class_id_;  // ID of the test fixture class 
+  bool should_run_;           // True if and only if this test should run 
+  bool is_disabled_;          // True if and only if 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
 
@@ -836,98 +836,98 @@ class GTEST_API_ TestInfo {
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
 };
 
-// A test suite, which consists of a vector of TestInfos.
+// A test suite, which consists of a vector of TestInfos. 
 //
-// TestSuite is not copyable.
-class GTEST_API_ TestSuite {
+// TestSuite is not copyable. 
+class GTEST_API_ TestSuite { 
  public:
-  // Creates a TestSuite with the given name.
+  // Creates a TestSuite with the given name. 
   //
-  // TestSuite does NOT have a default constructor.  Always use this
-  // constructor to create a TestSuite object.
+  // TestSuite does NOT have a default constructor.  Always use this 
+  // constructor to create a TestSuite object. 
   //
   // Arguments:
   //
-  //   name:         name of the test suite
+  //   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);
+  //   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();
+  // Destructor of TestSuite. 
+  virtual ~TestSuite(); 
 
-  // Gets the name of the 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.
+  // type-parameterized test suite. 
   const char* type_param() const {
-    if (type_param_.get() != nullptr) return type_param_->c_str();
-    return nullptr;
+    if (type_param_.get() != nullptr) return type_param_->c_str(); 
+    return nullptr; 
   }
 
-  // Returns true if any test in this test suite should run.
+  // 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.
+  // 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.
+  // 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.
+  // 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.
+  // 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.
+  // Gets the number of all tests in this test suite. 
   int total_test_count() const;
 
-  // Returns true if and only if the test suite passed.
+  // Returns true if and only if the test suite passed. 
   bool Passed() const { return !Failed(); }
 
-  // Returns true if and only if the test suite failed.
-  bool Failed() const {
-    return failed_test_count() > 0 || ad_hoc_test_result().Failed();
-  }
+  // Returns true if and only if the test suite failed. 
+  bool Failed() const { 
+    return failed_test_count() > 0 || ad_hoc_test_result().Failed(); 
+  } 
 
   // Returns the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
-  // Gets the time of the test suite start, in ms from the start of the
-  // UNIX epoch.
-  TimeInMillis start_timestamp() const { return start_timestamp_; }
-
+  // Gets the time of the test suite start, in ms from the start of the 
+  // UNIX epoch. 
+  TimeInMillis start_timestamp() const { return start_timestamp_; } 
+ 
   // 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.
+  // 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.
+  // 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.
+  // Gets the (immutable) vector of TestInfos in this TestSuite. 
   const std::vector<TestInfo*>& test_info_list() const {
     return test_info_list_;
   }
@@ -939,67 +939,67 @@ class GTEST_API_ TestSuite {
   // 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.
+  // 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.
+  // 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();
+  // 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.
+  // Runs every test in this TestSuite. 
   void Run();
 
-  // Skips the execution of tests under this TestSuite
-  void Skip();
-
-  // 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 if and only if test passed.
+  // Skips the execution of tests under this TestSuite 
+  void Skip(); 
+ 
+  // 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 if and only if test passed. 
   static bool TestPassed(const TestInfo* test_info) {
     return test_info->should_run() && test_info->result()->Passed();
   }
 
-  // Returns true if and only if test skipped.
-  static bool TestSkipped(const TestInfo* test_info) {
-    return test_info->should_run() && test_info->result()->Skipped();
-  }
-
-  // Returns true if and only if test failed.
+  // Returns true if and only if test skipped. 
+  static bool TestSkipped(const TestInfo* test_info) { 
+    return test_info->should_run() && test_info->result()->Skipped(); 
+  } 
+ 
+  // Returns true if and only if test failed. 
   static bool TestFailed(const TestInfo* test_info) {
     return test_info->should_run() && test_info->result()->Failed();
   }
 
-  // Returns true if and only if the test is disabled and will be reported in
-  // the XML report.
+  // Returns true if and only if 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 if and only if test is disabled.
+  // Returns true if and only if test is disabled. 
   static bool TestDisabled(const TestInfo* test_info) {
     return test_info->is_disabled_;
   }
 
-  // Returns true if and only if this test will appear in the XML report.
+  // Returns true if and only if this test will appear in the XML report. 
   static bool TestReportable(const TestInfo* test_info) {
     return test_info->is_reportable();
   }
@@ -1009,17 +1009,17 @@ class GTEST_API_ TestSuite {
     return test_info->should_run();
   }
 
-  // Shuffles the tests in this test suite.
+  // 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.
+  // 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_;
+  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_;
@@ -1027,22 +1027,22 @@ class GTEST_API_ TestSuite {
   // 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 if and only if any test in this test suite should run.
+  // 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 if and only if any test in this test suite should run. 
   bool should_run_;
-  // The start time, in milliseconds since UNIX Epoch.
-  TimeInMillis start_timestamp_;
+  // The start time, in milliseconds since UNIX Epoch. 
+  TimeInMillis start_timestamp_; 
   // Elapsed time, in milliseconds.
   TimeInMillis elapsed_time_;
-  // Holds test properties recorded during execution of SetUpTestSuite and
-  // TearDownTestSuite.
+  // 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);
+  // We disallow copying TestSuites. 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite); 
 };
 
 // An Environment object is capable of setting up and tearing down an
@@ -1073,21 +1073,21 @@ class Environment {
   // 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) {}
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; } 
 };
 
-#endif  // GTEST_HAS_EXCEPTIONS
-
+#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 {
@@ -1109,33 +1109,33 @@ class TestEventListener {
   // 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*/) {}
-
-  //  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  // Fired before the test suite starts. 
+  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*/) {} 
+#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.
+  // 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*/) {}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  // Fired after the test suite ends. 
+  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*/) {} 
+#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;
 
@@ -1157,30 +1157,30 @@ class 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& /*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& /*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 {}
+  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& /*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& /*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.
@@ -1220,7 +1220,7 @@ class GTEST_API_ TestEventListeners {
   }
 
  private:
-  friend class TestSuite;
+  friend class TestSuite; 
   friend class TestInfo;
   friend class internal::DefaultGlobalTestPartResultReporter;
   friend class internal::NoExecDeathTest;
@@ -1261,7 +1261,7 @@ class GTEST_API_ TestEventListeners {
   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
 };
 
-// A UnitTest consists of a vector of TestSuites.
+// 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
@@ -1290,15 +1290,15 @@ class GTEST_API_ UnitTest {
   // 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,
+  // 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
+  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
@@ -1307,40 +1307,40 @@ class GTEST_API_ UnitTest {
   // 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
+  // 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()
+  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 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 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. 
+  int total_test_suite_count() const; 
 
-  // Gets the number of all test suites that contain at least one test
+  // 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_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  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#endif  //  GTEST_REMOVE_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 skipped tests. 
+  int skipped_test_count() const; 
+ 
   // Gets the number of failed tests.
   int failed_test_count() const;
 
@@ -1366,25 +1366,25 @@ class GTEST_API_ UnitTest {
   // Gets the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const;
 
-  // Returns true if and only if the unit test passed (i.e. all test suites
-  // passed).
+  // Returns true if and only if the unit test passed (i.e. all test suites 
+  // passed). 
   bool Passed() const;
 
-  // Returns true if and only if the unit test failed (i.e. some test suite
-  // failed or something outside of all tests failed).
+  // Returns true if and only if 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_
+  // 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_
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 
   // Returns the TestResult containing information on test failures and
-  // properties logged outside of individual test suites.
+  // 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
@@ -1415,29 +1415,29 @@ class GTEST_API_ UnitTest {
       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
+  // 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);
+  // 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
+  // These classes and functions are friends as they need to access private 
   // members of UnitTest.
-  friend class ScopedTrace;
+  friend class ScopedTrace; 
   friend class Test;
   friend class internal::AssertHelper;
   friend class internal::StreamingListenerTest;
   friend class internal::UnitTestRecordPropertyTestHelper;
   friend Environment* AddGlobalTestEnvironment(Environment* env);
-  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
+  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites(); 
   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
   friend void internal::ReportFailureInUnknownLocation(
       TestPartResult::Type result_type,
@@ -1509,10 +1509,10 @@ GTEST_API_ void InitGoogleTest(int* argc, char** argv);
 // UNICODE mode.
 GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
 
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-GTEST_API_ void InitGoogleTest();
-
+// This overloaded version can be used on Arduino/embedded platforms where 
+// there is no argc/argv. 
+GTEST_API_ void InitGoogleTest(); 
+ 
 namespace internal {
 
 // Separate the error generating code from the code path to reduce the stack
@@ -1529,13 +1529,13 @@ AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                    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; }
-
+// 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,
@@ -1552,14 +1552,14 @@ AssertionResult CmpHelperEQ(const char* lhs_expression,
 class EqHelper {
  public:
   // This templatized version is for the general case.
-  template <
-      typename T1, typename T2,
-      // Disable this overload for cases where one argument is a pointer
-      // and the other is the null pointer constant.
-      typename std::enable_if<!std::is_integral<T1>::value ||
-                              !std::is_pointer<T2>::value>::type* = nullptr>
+  template < 
+      typename T1, typename T2, 
+      // Disable this overload for cases where one argument is a pointer 
+      // and the other is the null pointer constant. 
+      typename std::enable_if<!std::is_integral<T1>::value || 
+                              !std::is_pointer<T2>::value>::type* = nullptr> 
   static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression, const T1& lhs,
+                                 const char* rhs_expression, const T1& lhs, 
                                  const T2& rhs) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
@@ -1579,12 +1579,12 @@ class EqHelper {
 
   template <typename T>
   static AssertionResult Compare(
-      const char* lhs_expression, const char* rhs_expression,
-      // Handle cases where '0' is used as a null pointer literal.
-      std::nullptr_t /* lhs */, T* rhs) {
+      const char* lhs_expression, const char* rhs_expression, 
+      // Handle cases where '0' is used as a null pointer literal. 
+      std::nullptr_t /* lhs */, T* rhs) { 
     // We already know that 'lhs' is a null pointer.
-    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
-                       rhs);
+    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr), 
+                       rhs); 
   }
 };
 
@@ -1616,20 +1616,20 @@ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
   } else {\
     return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
   }\
-}
+} 
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
 // Implements the helper function for {ASSERT|EXPECT}_NE
-GTEST_IMPL_CMP_HELPER_(NE, !=)
+GTEST_IMPL_CMP_HELPER_(NE, !=) 
 // Implements the helper function for {ASSERT|EXPECT}_LE
-GTEST_IMPL_CMP_HELPER_(LE, <=)
+GTEST_IMPL_CMP_HELPER_(LE, <=) 
 // Implements the helper function for {ASSERT|EXPECT}_LT
-GTEST_IMPL_CMP_HELPER_(LT, <)
+GTEST_IMPL_CMP_HELPER_(LT, <) 
 // Implements the helper function for {ASSERT|EXPECT}_GE
-GTEST_IMPL_CMP_HELPER_(GE, >=)
+GTEST_IMPL_CMP_HELPER_(GE, >=) 
 // Implements the helper function for {ASSERT|EXPECT}_GT
-GTEST_IMPL_CMP_HELPER_(GT, >)
+GTEST_IMPL_CMP_HELPER_(GT, >) 
 
 #undef GTEST_IMPL_CMP_HELPER_
 
@@ -1825,13 +1825,13 @@ class GTEST_API_ AssertHelper {
 //   FooTest() {
 //     // Can use GetParam() here.
 //   }
-//   ~FooTest() override {
+//   ~FooTest() override { 
 //     // Can use GetParam() here.
 //   }
-//   void SetUp() override {
+//   void SetUp() override { 
 //     // Can use GetParam() here.
 //   }
-//   void TearDown override {
+//   void TearDown override { 
 //     // Can use GetParam() here.
 //   }
 // };
@@ -1840,7 +1840,7 @@ class GTEST_API_ AssertHelper {
 //   Foo foo;
 //   ASSERT_TRUE(foo.DoesBar(GetParam()));
 // }
-// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); 
 
 template <typename T>
 class WithParamInterface {
@@ -1849,9 +1849,9 @@ class WithParamInterface {
   virtual ~WithParamInterface() {}
 
   // The current parameter value. Is also available in the test fixture's
-  // constructor.
-  static const ParamType& GetParam() {
-    GTEST_CHECK_(parameter_ != nullptr)
+  // 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_;
@@ -1872,7 +1872,7 @@ class WithParamInterface {
 };
 
 template <typename T>
-const T* WithParamInterface<T>::parameter_ = nullptr;
+const T* WithParamInterface<T>::parameter_ = nullptr; 
 
 // Most value-parameterized classes can ignore the existence of
 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
@@ -1883,11 +1883,11 @@ 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_("")
-
+// Skips test in runtime. 
+// Skipping test aborts current function. 
+// Skipped tests are neither successful nor failed. 
+#define GTEST_SKIP() GTEST_SKIP_("") 
+ 
 // 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
@@ -1917,11 +1917,11 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // Generates a fatal failure with a generic message.
 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
 
-// Like GTEST_FAIL(), but at the given source file location.
-#define GTEST_FAIL_AT(file, line)         \
-  GTEST_MESSAGE_AT_(file, line, "Failed", \
-                    ::testing::TestPartResult::kFatalFailure)
-
+// Like GTEST_FAIL(), but at the given source file location. 
+#define GTEST_FAIL_AT(file, line)         \ 
+  GTEST_MESSAGE_AT_(file, line, "Failed", \ 
+                    ::testing::TestPartResult::kFatalFailure) 
+ 
 // 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
@@ -1962,38 +1962,38 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 // 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 GTEST_EXPECT_TRUE(condition) \
+#define GTEST_EXPECT_TRUE(condition) \ 
   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                       GTEST_NONFATAL_FAILURE_)
-#define GTEST_EXPECT_FALSE(condition) \
+#define GTEST_EXPECT_FALSE(condition) \ 
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_NONFATAL_FAILURE_)
-#define GTEST_ASSERT_TRUE(condition) \
+#define GTEST_ASSERT_TRUE(condition) \ 
   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                       GTEST_FATAL_FAILURE_)
-#define GTEST_ASSERT_FALSE(condition) \
+#define GTEST_ASSERT_FALSE(condition) \ 
   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                       GTEST_FATAL_FAILURE_)
 
-// Define these macros to 1 to omit the definition of the corresponding
-// EXPECT or ASSERT, which clashes with some users' own code.
-
-#if !GTEST_DONT_DEFINE_EXPECT_TRUE
-#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
-#endif
-
-#if !GTEST_DONT_DEFINE_EXPECT_FALSE
-#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_TRUE
-#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
-#endif
-
-#if !GTEST_DONT_DEFINE_ASSERT_FALSE
-#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
-#endif
-
+// Define these macros to 1 to omit the definition of the corresponding 
+// EXPECT or ASSERT, which clashes with some users' own code. 
+ 
+#if !GTEST_DONT_DEFINE_EXPECT_TRUE 
+#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition) 
+#endif 
+ 
+#if !GTEST_DONT_DEFINE_EXPECT_FALSE 
+#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition) 
+#endif 
+ 
+#if !GTEST_DONT_DEFINE_ASSERT_TRUE 
+#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition) 
+#endif 
+ 
+#if !GTEST_DONT_DEFINE_ASSERT_FALSE 
+#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition) 
+#endif 
+ 
 // Macros for testing equalities and inequalities.
 //
 //    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
@@ -2035,13 +2035,13 @@ class TestWithParam : public Test, public WithParamInterface<T> {
 //
 // Examples:
 //
-//   EXPECT_NE(Foo(), 5);
-//   EXPECT_EQ(a_pointer, NULL);
+//   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::Compare, val1, val2)
+  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) 
 #define EXPECT_NE(val1, val2) \
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
 #define EXPECT_LE(val1, val2) \
@@ -2054,7 +2054,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {
   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
 
 #define GTEST_ASSERT_EQ(val1, val2) \
-  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2) 
 #define GTEST_ASSERT_NE(val1, val2) \
   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
 #define GTEST_ASSERT_LE(val1, val2) \
@@ -2218,51 +2218,51 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
 #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)");
-  }
-
-  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 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)"); 
+  } 
+ 
+  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
@@ -2274,17 +2274,17 @@ class GTEST_API_ ScopedTrace {
 // 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.
+// 
+// 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))
+  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ 
+    __FILE__, __LINE__, (message)) 
 
 // Compile-time assertion for type equality.
-// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
-// are the same type.  The value it returns is not interesting.
+// StaticAssertTypeEq<type1, type2>() compiles if and only if 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
@@ -2313,18 +2313,18 @@ class GTEST_API_ ScopedTrace {
 //
 // to cause a compiler error.
 template <typename T1, typename T2>
-constexpr bool StaticAssertTypeEq() noexcept {
-  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
+constexpr bool StaticAssertTypeEq() noexcept { 
+  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type"); 
   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 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.
+// 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:
@@ -2343,28 +2343,28 @@ constexpr bool StaticAssertTypeEq() noexcept {
 // 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 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)
+#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.
+// 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:
+// the test code between braces after using this macro.  Example: 
 //
 //   class FooTest : public testing::Test {
 //    protected:
-//     void SetUp() override { b_.AddElement(3); }
+//     void SetUp() override { b_.AddElement(3); } 
 //
 //     Foo a_;
 //     Foo b_;
@@ -2375,105 +2375,105 @@ constexpr bool StaticAssertTypeEq() noexcept {
 //   }
 //
 //   TEST_F(FooTest, ReturnsElementCountCorrectly) {
-//     EXPECT_EQ(a_.size(), 0);
-//     EXPECT_EQ(b_.size(), 1);
+//     EXPECT_EQ(a_.size(), 0); 
+//     EXPECT_EQ(b_.size(), 1); 
 //   }
-//
-// GOOGLETEST_CM0011 DO NOT DELETE
-#if !GTEST_DONT_DEFINE_TEST
+// 
+// GOOGLETEST_CM0011 DO NOT DELETE 
+#if !GTEST_DONT_DEFINE_TEST 
 #define TEST_F(test_fixture, test_name)\
   GTEST_TEST_(test_fixture, test_name, test_fixture, \
               ::testing::internal::GetTypeId<test_fixture>())
-#endif  // !GTEST_DONT_DEFINE_TEST
-
-// 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(file, line),
-      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
-      new FactoryImpl{std::move(factory)});
-}
-
+#endif  // !GTEST_DONT_DEFINE_TEST 
+
+// 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(file, line), 
+      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line), 
+      new FactoryImpl{std::move(factory)}); 
+} 
+ 
 }  // namespace testing
 
 // Use this function in main() to run all tests.  It returns 0 if all
@@ -2490,6 +2490,6 @@ inline int RUN_ALL_TESTS() {
   return ::testing::UnitTest::GetInstance()->Run();
 }
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest_pred_impl.h b/contrib/restricted/googletest/googletest/include/gtest/gtest_pred_impl.h
index 5029a9bb02..4a1a8fe65f 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest_pred_impl.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest_pred_impl.h
@@ -27,19 +27,19 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
+// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command 
 // 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
 //
 // Implements a family of generic predicate assertion macros.
-// GOOGLETEST_CM0001 DO NOT DELETE
+// GOOGLETEST_CM0001 DO NOT DELETE 
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 
 
-#include "gtest/gtest.h"
-
-namespace testing {
+#include "gtest/gtest.h" 
 
+namespace testing { 
+ 
 // This header implements a family of generic predicate assertion
 // macros:
 //
@@ -90,10 +90,10 @@ AssertionResult AssertPred1Helper(const char* pred_text,
                                   const T1& v1) {
   if (pred(v1)) return AssertionSuccess();
 
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1);
+  return AssertionFailure() 
+         << pred_text << "(" << e1 << ") evaluates to false, where" 
+         << "\n" 
+         << e1 << " evaluates to " << ::testing::PrintToString(v1); 
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
@@ -135,12 +135,12 @@ AssertionResult AssertPred2Helper(const char* pred_text,
                                   const T2& v2) {
   if (pred(v1, v2)) return AssertionSuccess();
 
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2);
+  return AssertionFailure() 
+         << pred_text << "(" << e1 << ", " << e2 
+         << ") evaluates to false, where" 
+         << "\n" 
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" 
+         << e2 << " evaluates to " << ::testing::PrintToString(v2); 
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
@@ -187,13 +187,13 @@ AssertionResult AssertPred3Helper(const char* pred_text,
                                   const T3& v3) {
   if (pred(v1, v2, v3)) return AssertionSuccess();
 
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3);
+  return AssertionFailure() 
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 
+         << ") evaluates to false, where" 
+         << "\n" 
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" 
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" 
+         << e3 << " evaluates to " << ::testing::PrintToString(v3); 
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
@@ -245,14 +245,14 @@ AssertionResult AssertPred4Helper(const char* pred_text,
                                   const T4& v4) {
   if (pred(v1, v2, v3, v4)) return AssertionSuccess();
 
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
-         << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
-         << e4 << " evaluates to " << ::testing::PrintToString(v4);
+  return AssertionFailure() 
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 
+         << ") evaluates to false, where" 
+         << "\n" 
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" 
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" 
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n" 
+         << e4 << " evaluates to " << ::testing::PrintToString(v4); 
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
@@ -309,15 +309,15 @@ AssertionResult AssertPred5Helper(const char* pred_text,
                                   const T5& v5) {
   if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
 
-  return AssertionFailure()
-         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
-         << ", " << e5 << ") evaluates to false, where"
-         << "\n"
-         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
-         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
-         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
-         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
-         << e5 << " evaluates to " << ::testing::PrintToString(v5);
+  return AssertionFailure() 
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 
+         << ", " << e5 << ") evaluates to false, where" 
+         << "\n" 
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n" 
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n" 
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n" 
+         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n" 
+         << e5 << " evaluates to " << ::testing::PrintToString(v5); 
 }
 
 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
@@ -354,6 +354,6 @@ AssertionResult AssertPred5Helper(const char* pred_text,
 
 
 
-}  // namespace testing
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+}  // namespace testing 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/gtest_prod.h b/contrib/restricted/googletest/googletest/include/gtest/gtest_prod.h
index 38b9d85a51..48b76cdf11 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/gtest_prod.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/gtest_prod.h
@@ -26,13 +26,13 @@
 // 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.
-
+ 
 //
-// Google C++ Testing and Mocking Framework definitions useful in production code.
-// GOOGLETEST_CM0003 DO NOT DELETE
+// Google C++ Testing and Mocking Framework definitions useful in production code. 
+// GOOGLETEST_CM0003 DO NOT DELETE 
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ 
 
 // When you need to test the private or protected members of a class,
 // use the FRIEND_TEST macro to declare your tests as friends of the
@@ -40,22 +40,22 @@
 //
 // class MyClass {
 //  private:
-//   void PrivateMethod();
-//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
+//   void PrivateMethod(); 
+//   FRIEND_TEST(MyClassTest, PrivateMethodWorks); 
 // };
 //
 // class MyClassTest : public testing::Test {
 //   // ...
 // };
 //
-// TEST_F(MyClassTest, PrivateMethodWorks) {
-//   // Can call MyClass::PrivateMethod() here.
+// TEST_F(MyClassTest, PrivateMethodWorks) { 
+//   // Can call MyClass::PrivateMethod() here. 
 // }
-//
-// Note: The test class must be in the same namespace as the class being tested.
-// For example, putting MyClassTest in an anonymous namespace will not work.
+// 
+// Note: The test class must be in the same namespace as the class being tested. 
+// For example, putting MyClassTest in an anonymous namespace will not work. 
 
 #define FRIEND_TEST(test_case_name, test_name)\
 friend class test_case_name##_##test_name##_Test
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-port.h b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-port.h
index 74b2c76e37..e7b2c648cc 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-port.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-port.h
@@ -27,56 +27,56 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// Injection point for custom user configurations. See README for details
+// Injection point for custom user configurations. See README for details 
 //
 // ** Custom implementation starts here **
 
 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
 #define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
 
-#include <re2/re2.h>
-
-// this macro disables built-in implementation of class RE
-#define GTEST_USES_PCRE 1
-
-namespace testing::internal {
-    // custom implementation of class RE based on re2
-
-    class RE {
-    public:
-        RE(const char* regex) : re2_(regex) {}
-        RE(const std::string& regex) : re2_(regex) {}
-
-        RE(const RE& other) : RE(other.pattern()) {}
-
-        // Returns the string representation of the regex.
-        const char* pattern() const {
-            return re2_.pattern().c_str();
-        }
-
-        // FullMatch(str, re) returns true if and only if regular expression re
-        // matches the entire str.
-        static bool FullMatch(const ::std::string& str, const RE& re) {
-            return FullMatch(str.c_str(), re);
-        }
-
-        // PartialMatch(str, re) returns true if and only if regular expression re
-        // matches a substring of str (including str itself).
-        static bool PartialMatch(const ::std::string& str, const RE& re) {
-            return PartialMatch(str.c_str(), re);
-        }
-
-        static bool FullMatch(const char* str, const RE& re) {
-            return re2::RE2::FullMatchN(str, re.re2_, nullptr, 0);
-        }
-
-        static bool PartialMatch(const char* str, const RE& re) {
-            return re2::RE2::PartialMatchN(str, re.re2_, nullptr, 0);
-        }
-
-    private:
-        re2::RE2 re2_;
-    };
-}
-
+#include <re2/re2.h> 
+ 
+// this macro disables built-in implementation of class RE 
+#define GTEST_USES_PCRE 1 
+ 
+namespace testing::internal { 
+    // custom implementation of class RE based on re2 
+ 
+    class RE { 
+    public: 
+        RE(const char* regex) : re2_(regex) {} 
+        RE(const std::string& regex) : re2_(regex) {} 
+ 
+        RE(const RE& other) : RE(other.pattern()) {} 
+ 
+        // Returns the string representation of the regex. 
+        const char* pattern() const { 
+            return re2_.pattern().c_str(); 
+        } 
+ 
+        // FullMatch(str, re) returns true if and only if regular expression re 
+        // matches the entire str. 
+        static bool FullMatch(const ::std::string& str, const RE& re) { 
+            return FullMatch(str.c_str(), re); 
+        } 
+ 
+        // PartialMatch(str, re) returns true if and only if regular expression re 
+        // matches a substring of str (including str itself). 
+        static bool PartialMatch(const ::std::string& str, const RE& re) { 
+            return PartialMatch(str.c_str(), re); 
+        } 
+ 
+        static bool FullMatch(const char* str, const RE& re) { 
+            return re2::RE2::FullMatchN(str, re.re2_, nullptr, 0); 
+        } 
+ 
+        static bool PartialMatch(const char* str, const RE& re) { 
+            return re2::RE2::PartialMatchN(str, re.re2_, nullptr, 0); 
+        } 
+ 
+    private: 
+        re2::RE2 re2_; 
+    }; 
+} 
+ 
 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-printers.h b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
index b9495d8378..9d2632363a 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest-printers.h
@@ -32,11 +32,11 @@
 // It will be included from gtest-printers.h and the overrides in this file
 // will be visible to everyone.
 //
-// Injection point for custom user configurations. See README for details
-//
+// Injection point for custom user configurations. See README for details 
+// 
 // ** Custom implementation starts here **
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest.h b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest.h
index afaaf17ba2..36f07a9389 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/custom/gtest.h
@@ -27,11 +27,11 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// Injection point for custom user configurations. See README for details
+// Injection point for custom user configurations. See README for details 
 //
 // ** Custom implementation starts here **
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
index 490296dfad..060b0a3d85 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -27,20 +27,20 @@
 // (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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file defines internal utilities needed for implementing
 // death tests.  They are subject to change without notice.
-// GOOGLETEST_CM0001 DO NOT DELETE
+// GOOGLETEST_CM0001 DO NOT DELETE 
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ 
 
-#include "gtest/gtest-matchers.h"
+#include "gtest/gtest-matchers.h" 
 #include "gtest/internal/gtest-internal.h"
 
 #include <stdio.h>
-#include <memory>
+#include <memory> 
 
 namespace testing {
 namespace internal {
@@ -54,9 +54,9 @@ const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
 
 #if GTEST_HAS_DEATH_TEST
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 // DeathTest is a class that hides much of the complexity of the
 // GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
 // returns a concrete class that depends on the prevailing death test
@@ -80,7 +80,7 @@ class GTEST_API_ DeathTest {
   // argument is set.  If the death test should be skipped, the pointer
   // is set to NULL; otherwise, it is set to the address of a new concrete
   // DeathTest object that controls the execution of the current test.
-  static bool Create(const char* statement, Matcher<const std::string&> matcher,
+  static bool Create(const char* statement, Matcher<const std::string&> matcher, 
                      const char* file, int line, DeathTest** test);
   DeathTest();
   virtual ~DeathTest() { }
@@ -140,50 +140,50 @@ class GTEST_API_ DeathTest {
   GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
 };
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
 // Factory interface for death tests.  May be mocked out for testing.
 class DeathTestFactory {
  public:
   virtual ~DeathTestFactory() { }
-  virtual bool Create(const char* statement,
-                      Matcher<const std::string&> matcher, const char* file,
-                      int line, DeathTest** test) = 0;
+  virtual bool Create(const char* statement, 
+                      Matcher<const std::string&> matcher, const char* file, 
+                      int line, DeathTest** test) = 0; 
 };
 
 // A concrete DeathTestFactory implementation for normal use.
 class DefaultDeathTestFactory : public DeathTestFactory {
  public:
-  bool Create(const char* statement, Matcher<const std::string&> matcher,
-              const char* file, int line, DeathTest** test) override;
+  bool Create(const char* statement, Matcher<const std::string&> matcher, 
+              const char* file, int line, DeathTest** test) override; 
 };
 
 // Returns true if exit_status describes a process that was terminated
 // by a signal, or exited normally with a nonzero exit code.
 GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
 
-// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
-// and interpreted as a regex (rather than an Eq matcher) for legacy
-// compatibility.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    ::testing::internal::RE regex) {
-  return ContainsRegex(regex.pattern());
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
-  return ContainsRegex(regex);
-}
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    const ::std::string& regex) {
-  return ContainsRegex(regex);
-}
-
-// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
-// used directly.
-inline Matcher<const ::std::string&> MakeDeathTestMatcher(
-    Matcher<const ::std::string&> matcher) {
-  return matcher;
-}
-
+// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads 
+// and interpreted as a regex (rather than an Eq matcher) for legacy 
+// compatibility. 
+inline Matcher<const ::std::string&> MakeDeathTestMatcher( 
+    ::testing::internal::RE regex) { 
+  return ContainsRegex(regex.pattern()); 
+} 
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) { 
+  return ContainsRegex(regex); 
+} 
+inline Matcher<const ::std::string&> MakeDeathTestMatcher( 
+    const ::std::string& regex) { 
+  return ContainsRegex(regex); 
+} 
+ 
+// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's 
+// used directly. 
+inline Matcher<const ::std::string&> MakeDeathTestMatcher( 
+    Matcher<const ::std::string&> matcher) { 
+  return matcher; 
+} 
+ 
 // Traps C++ exceptions escaping statement and reports them as test
 // failures. Note that trapping SEH exceptions is not implemented here.
 # if GTEST_HAS_EXCEPTIONS
@@ -211,53 +211,53 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
 
 // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
 // ASSERT_EXIT*, and EXPECT_EXIT*.
-#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
-  if (::testing::internal::AlwaysTrue()) {                                     \
-    ::testing::internal::DeathTest* gtest_dt;                                  \
-    if (!::testing::internal::DeathTest::Create(                               \
-            #statement,                                                        \
-            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
-            __FILE__, __LINE__, &gtest_dt)) {                                  \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
-    }                                                                          \
-    if (gtest_dt != nullptr) {                                                 \
-      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
-      switch (gtest_dt->AssumeRole()) {                                        \
-        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
-          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
-            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
-          }                                                                    \
-          break;                                                               \
-        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
-          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
-              gtest_dt);                                                       \
-          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
-          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
-          break;                                                               \
-        }                                                                      \
-        default:                                                               \
-          break;                                                               \
-      }                                                                        \
-    }                                                                          \
-  } else                                                                       \
-    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
-        : fail(::testing::internal::DeathTest::LastMessage())
+#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \ 
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \ 
+  if (::testing::internal::AlwaysTrue()) {                                     \ 
+    ::testing::internal::DeathTest* gtest_dt;                                  \ 
+    if (!::testing::internal::DeathTest::Create(                               \ 
+            #statement,                                                        \ 
+            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \ 
+            __FILE__, __LINE__, &gtest_dt)) {                                  \ 
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \ 
+    }                                                                          \ 
+    if (gtest_dt != nullptr) {                                                 \ 
+      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \ 
+      switch (gtest_dt->AssumeRole()) {                                        \ 
+        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \ 
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \ 
+            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \ 
+          }                                                                    \ 
+          break;                                                               \ 
+        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \ 
+          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \ 
+              gtest_dt);                                                       \ 
+          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \ 
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \ 
+          break;                                                               \ 
+        }                                                                      \ 
+        default:                                                               \ 
+          break;                                                               \ 
+      }                                                                        \ 
+    }                                                                          \ 
+  } else                                                                       \ 
+    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \ 
+        : fail(::testing::internal::DeathTest::LastMessage()) 
 // The symbol "fail" here expands to something into which a message
 // can be streamed.
 
 // This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
-// NDEBUG mode. In this case we need the statements to be executed and the macro
-// must accept a streamed message even though the message is never printed.
-// The regex object is not evaluated, but it is used to prevent "unused"
-// warnings and to avoid an expression that doesn't compile in debug mode.
-#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
-  if (::testing::internal::AlwaysTrue()) {                       \
-    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
-  } else if (!::testing::internal::AlwaysTrue()) {               \
-    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
-  } else                                                         \
+// NDEBUG mode. In this case we need the statements to be executed and the macro 
+// must accept a streamed message even though the message is never printed. 
+// The regex object is not evaluated, but it is used to prevent "unused" 
+// warnings and to avoid an expression that doesn't compile in debug mode. 
+#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \ 
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \ 
+  if (::testing::internal::AlwaysTrue()) {                       \ 
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \ 
+  } else if (!::testing::internal::AlwaysTrue()) {               \ 
+    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \ 
+  } else                                                         \ 
     ::testing::Message()
 
 // A class representing the parsed contents of the
@@ -301,4 +301,4 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
 }  // namespace internal
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-filepath.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-filepath.h
index 0c033abc34..7b4797c93c 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-filepath.h
@@ -32,19 +32,19 @@
 // This header file declares classes and functions used internally by
 // Google Test.  They are subject to change without notice.
 //
-// This file is #included in gtest/internal/gtest-internal.h.
+// This file is #included in gtest/internal/gtest-internal.h. 
 // Do not include this header file separately!
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ 
 
 #include "gtest/internal/gtest-string.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 namespace internal {
 
@@ -110,7 +110,7 @@ class GTEST_API_ FilePath {
                                          const FilePath& base_name,
                                          const char* extension);
 
-  // Returns true if and only if the path is "".
+  // Returns true if and only if the path is "". 
   bool IsEmpty() const { return pathname_.empty(); }
 
   // If input name has a trailing separator character, removes it and returns
@@ -195,7 +195,7 @@ class GTEST_API_ FilePath {
 
   void Normalize();
 
-  // Returns a pointer to the last occurrence of a valid path separator in
+  // Returns a pointer to the last occurrence of a valid path separator in 
   // the FilePath. On Windows, for example, both '/' and '\' are valid path
   // separators. Returns NULL if no path separator was found.
   const char* FindLastPathSeparator() const;
@@ -206,6 +206,6 @@ class GTEST_API_ FilePath {
 }  // namespace internal
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-internal.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-internal.h
index e53b5b593b..6a2a34407d 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-internal.h
@@ -27,15 +27,15 @@
 // (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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file declares functions and macros used internally by
 // Google Test.  They are subject to change without notice.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 
 
 #include "gtest/internal/gtest-port.h"
 
@@ -53,17 +53,17 @@
 #include <ctype.h>
 #include <float.h>
 #include <string.h>
-#include <cstdint>
+#include <cstdint> 
 #include <iomanip>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
-#include <type_traits>
+#include <type_traits> 
 #include <vector>
 
 #include "gtest/gtest-message.h"
-#include "gtest/internal/gtest-filepath.h"
+#include "gtest/internal/gtest-filepath.h" 
 #include "gtest/internal/gtest-string.h"
 #include "gtest/internal/gtest-type-util.h"
 
@@ -78,21 +78,21 @@
 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
 
-// Stringifies its argument.
-// Work around a bug in visual studio which doesn't accept code like this:
-//
-//   #define GTEST_STRINGIFY_(name) #name
-//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ...
-//   MACRO(, x, y)
-//
-// Complaining about the argument to GTEST_STRINGIFY_ being empty.
-// This is allowed by the spec.
-#define GTEST_STRINGIFY_HELPER_(name, ...) #name
-#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
-
-namespace proto2 {
-class MessageLite;
-}
+// Stringifies its argument. 
+// Work around a bug in visual studio which doesn't accept code like this: 
+// 
+//   #define GTEST_STRINGIFY_(name) #name 
+//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ... 
+//   MACRO(, x, y) 
+// 
+// Complaining about the argument to GTEST_STRINGIFY_ being empty. 
+// This is allowed by the spec. 
+#define GTEST_STRINGIFY_HELPER_(name, ...) #name 
+#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, ) 
+ 
+namespace proto2 { 
+class MessageLite; 
+} 
 
 namespace testing {
 
@@ -103,7 +103,7 @@ class Message;                         // Represents a failure message.
 class Test;                            // Represents a test.
 class TestInfo;                        // Information about a test.
 class TestPartResult;                  // Result of a test part.
-class UnitTest;                        // A collection of test suites.
+class UnitTest;                        // A collection of test suites. 
 
 template <typename T>
 ::std::string PrintToString(const T& value);
@@ -118,22 +118,22 @@ class UnitTestImpl;                    // Opaque implementation of UnitTest
 // stack trace.
 GTEST_API_ extern const char kStackTraceMarker[];
 
-// An IgnoredValue object can be implicitly constructed from ANY value.
-class IgnoredValue {
-  struct Sink {};
- public:
-  // This constructor template allows any value to be implicitly
-  // converted to IgnoredValue.  The object has no data member and
-  // doesn't try to remember anything about the argument.  We
-  // deliberately omit the 'explicit' keyword in order to allow the
-  // conversion to be implicit.
-  // Disable the conversion if T already has a magical conversion operator.
-  // Otherwise we get ambiguity.
-  template <typename T,
-            typename std::enable_if<!std::is_convertible<T, Sink>::value,
-                                    int>::type = 0>
-  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
-};
+// An IgnoredValue object can be implicitly constructed from ANY value. 
+class IgnoredValue { 
+  struct Sink {}; 
+ public: 
+  // This constructor template allows any value to be implicitly 
+  // converted to IgnoredValue.  The object has no data member and 
+  // doesn't try to remember anything about the argument.  We 
+  // deliberately omit the 'explicit' keyword in order to allow the 
+  // conversion to be implicit. 
+  // Disable the conversion if T already has a magical conversion operator. 
+  // Otherwise we get ambiguity. 
+  template <typename T, 
+            typename std::enable_if<!std::is_convertible<T, Sink>::value, 
+                                    int>::type = 0> 
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit) 
+}; 
 
 // Appends the user-supplied message to the Google-Test-generated message.
 GTEST_API_ std::string AppendUserMessage(
@@ -141,9 +141,9 @@ GTEST_API_ std::string AppendUserMessage(
 
 #if GTEST_HAS_EXCEPTIONS
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
-/* an exported class was derived from a class that was not exported */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \ 
+/* an exported class was derived from a class that was not exported */) 
+ 
 // This exception is thrown by (and only by) a failed Google Test
 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
 // are enabled).  We derive it from std::runtime_error, which is for
@@ -155,15 +155,15 @@ class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
   explicit GoogleTestFailureException(const TestPartResult& failure);
 };
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275
-
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275 
+ 
 #endif  // GTEST_HAS_EXCEPTIONS
 
 namespace edit_distance {
 // Returns the optimal edits to go from 'left' to 'right'.
 // All edits cost the same, with replace having lower priority than
 // add/remove.
-// Simple implementation of the Wagner-Fischer algorithm.
+// Simple implementation of the Wagner-Fischer algorithm. 
 // See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
 enum EditType { kMatch, kAdd, kRemove, kReplace };
 GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
@@ -201,7 +201,7 @@ GTEST_API_ std::string DiffStrings(const std::string& left,
 //   expected_value:      "5"
 //   actual_value:        "6"
 //
-// The ignoring_case parameter is true if and only if the assertion is a
+// The ignoring_case parameter is true if and only if the assertion is a 
 // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
 // be inserted into the message.
 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
@@ -287,7 +287,7 @@ class FloatingPoint {
   //
   // See the following article for more details on ULP:
   // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
-  static const uint32_t kMaxUlps = 4;
+  static const uint32_t kMaxUlps = 4; 
 
   // Constructs a FloatingPoint from a raw floating-point number.
   //
@@ -330,15 +330,15 @@ class FloatingPoint {
   // Returns the sign bit of this number.
   Bits sign_bit() const { return kSignBitMask & u_.bits_; }
 
-  // Returns true if and only if this is NAN (not a number).
+  // Returns true if and only if this is NAN (not a number). 
   bool is_nan() const {
     // It's a NAN if the exponent bits are all ones and the fraction
     // bits are not entirely zeros.
     return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
   }
 
-  // Returns true if and only if this number is at most kMaxUlps ULP's away
-  // from rhs.  In particular, this function:
+  // Returns true if and only if this number is at most kMaxUlps ULP's away 
+  // from rhs.  In particular, this function: 
   //
   //   - returns false if either number is (or both are) NAN.
   //   - treats really large numbers as almost equal to infinity.
@@ -409,7 +409,7 @@ typedef FloatingPoint<float> Float;
 typedef FloatingPoint<double> Double;
 
 // In order to catch the mistake of putting tests that use different
-// test fixture classes in the same test suite, we need to assign
+// test fixture classes in the same test suite, we need to assign 
 // unique IDs to fixture classes and compare them.  The TypeId type is
 // used to hold such IDs.  The user should treat TypeId as an opaque
 // type: the only operation allowed on TypeId values is to compare
@@ -469,7 +469,7 @@ class TestFactoryBase {
 template <class TestClass>
 class TestFactoryImpl : public TestFactoryBase {
  public:
-  Test* CreateTest() override { return new TestClass; }
+  Test* CreateTest() override { return new TestClass; } 
 };
 
 #if GTEST_OS_WINDOWS
@@ -485,128 +485,128 @@ GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
 
 #endif  // GTEST_OS_WINDOWS
 
-// Types of SetUpTestSuite() and TearDownTestSuite() functions.
-using SetUpTestSuiteFunc = void (*)();
-using TearDownTestSuiteFunc = void (*)();
+// Types of SetUpTestSuite() and TearDownTestSuite() functions. 
+using SetUpTestSuiteFunc = void (*)(); 
+using TearDownTestSuiteFunc = void (*)(); 
 
 struct CodeLocation {
-  CodeLocation(const std::string& a_file, int a_line)
-      : file(a_file), line(a_line) {}
+  CodeLocation(const std::string& a_file, int a_line) 
+      : file(a_file), line(a_line) {} 
 
-  std::string file;
+  std::string file; 
   int line;
 };
 
-//  Helper to identify which setup function for TestCase / TestSuite to call.
-//  Only one function is allowed, either TestCase or TestSute but not both.
-
-// Utility functions to help SuiteApiResolver
-using SetUpTearDownSuiteFuncType = void (*)();
-
-inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
-    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
-  return a == def ? nullptr : a;
-}
-
-template <typename T>
-//  Note that SuiteApiResolver inherits from T because
-//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
-//  SuiteApiResolver can access them.
-struct SuiteApiResolver : T {
-  // testing::Test is only forward declared at this point. So we make it a
-  // dependend class for the compiler to be OK with it.
-  using Test =
-      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
-
-  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
-                                                        int line_num) {
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-    SetUpTearDownSuiteFuncType test_case_fp =
-        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
-    SetUpTearDownSuiteFuncType test_suite_fp =
-        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
-
-    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
-        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
-           "make sure there is only one present at "
-        << filename << ":" << line_num;
-
-    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
-#else
-    (void)(filename);
-    (void)(line_num);
-    return &T::SetUpTestSuite;
-#endif
-  }
-
-  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
-                                                           int line_num) {
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-    SetUpTearDownSuiteFuncType test_case_fp =
-        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
-    SetUpTearDownSuiteFuncType test_suite_fp =
-        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
-
-    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
-        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
-           " please make sure there is only one present at"
-        << filename << ":" << line_num;
-
-    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
-#else
-    (void)(filename);
-    (void)(line_num);
-    return &T::TearDownTestSuite;
-#endif
-  }
-};
-
+//  Helper to identify which setup function for TestCase / TestSuite to call. 
+//  Only one function is allowed, either TestCase or TestSute but not both. 
+ 
+// Utility functions to help SuiteApiResolver 
+using SetUpTearDownSuiteFuncType = void (*)(); 
+ 
+inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull( 
+    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) { 
+  return a == def ? nullptr : a; 
+} 
+ 
+template <typename T> 
+//  Note that SuiteApiResolver inherits from T because 
+//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way 
+//  SuiteApiResolver can access them. 
+struct SuiteApiResolver : T { 
+  // testing::Test is only forward declared at this point. So we make it a 
+  // dependend class for the compiler to be OK with it. 
+  using Test = 
+      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type; 
+ 
+  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename, 
+                                                        int line_num) { 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+    SetUpTearDownSuiteFuncType test_case_fp = 
+        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase); 
+    SetUpTearDownSuiteFuncType test_suite_fp = 
+        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite); 
+ 
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp) 
+        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please " 
+           "make sure there is only one present at " 
+        << filename << ":" << line_num; 
+ 
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp; 
+#else 
+    (void)(filename); 
+    (void)(line_num); 
+    return &T::SetUpTestSuite; 
+#endif 
+  } 
+ 
+  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename, 
+                                                           int line_num) { 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+    SetUpTearDownSuiteFuncType test_case_fp = 
+        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase); 
+    SetUpTearDownSuiteFuncType test_suite_fp = 
+        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite); 
+ 
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp) 
+        << "Test can not provide both TearDownTestSuite and TearDownTestCase," 
+           " please make sure there is only one present at" 
+        << filename << ":" << line_num; 
+ 
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp; 
+#else 
+    (void)(filename); 
+    (void)(line_num); 
+    return &T::TearDownTestSuite; 
+#endif 
+  } 
+}; 
+ 
 // Creates a new TestInfo object and registers it with Google Test;
 // returns the created object.
 //
 // Arguments:
 //
-//   test_suite_name:  name of the test suite
+//   test_suite_name:  name of the test suite 
 //   name:             name of the test
-//   type_param:       the name of the test's type parameter, or NULL if
+//   type_param:       the name of the test's type parameter, or NULL if 
 //                     this is not a typed or a type-parameterized test.
-//   value_param:      text representation of the test's value parameter,
+//   value_param:      text representation of the test's value parameter, 
 //                     or NULL if this is not a type-parameterized test.
 //   code_location:    code location where the test is defined
 //   fixture_class_id: ID of the test fixture class
-//   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
+//   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 
 //   factory:          pointer to the factory that creates a test object.
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    const char* test_suite_name, const char* name, const char* type_param,
-    const char* value_param, CodeLocation code_location,
-    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
-    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
+    const char* test_suite_name, const char* name, const char* type_param, 
+    const char* value_param, CodeLocation code_location, 
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, 
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory); 
 
 // If *pstr starts with the given prefix, modifies *pstr to be right
 // past the prefix and returns true; otherwise leaves *pstr unchanged
 // and returns false.  None of pstr, *pstr, and prefix can be NULL.
 GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
-// State of the definition of a type-parameterized test suite.
-class GTEST_API_ TypedTestSuitePState {
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
+// State of the definition of a type-parameterized test suite. 
+class GTEST_API_ TypedTestSuitePState { 
  public:
-  TypedTestSuitePState() : registered_(false) {}
+  TypedTestSuitePState() : registered_(false) {} 
 
   // Adds the given test name to defined_test_names_ and return true
-  // if the test suite hasn't been registered; otherwise aborts the
+  // if the test suite hasn't been registered; otherwise aborts the 
   // program.
   bool AddTestName(const char* file, int line, const char* case_name,
                    const char* test_name) {
     if (registered_) {
-      fprintf(stderr,
-              "%s Test %s must be defined before "
-              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
+      fprintf(stderr, 
+              "%s Test %s must be defined before " 
+              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n", 
               FormatFileLocation(file, line).c_str(), test_name, case_name);
       fflush(stderr);
       posix::Abort();
@@ -629,9 +629,9 @@ class GTEST_API_ TypedTestSuitePState {
   // Verifies that registered_tests match the test names in
   // defined_test_names_; returns registered_tests if successful, or
   // aborts the program otherwise.
-  const char* VerifyRegisteredTestNames(const char* test_suite_name,
-                                        const char* file, int line,
-                                        const char* registered_tests);
+  const char* VerifyRegisteredTestNames(const char* test_suite_name, 
+                                        const char* file, int line, 
+                                        const char* registered_tests); 
 
  private:
   typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
@@ -640,19 +640,19 @@ class GTEST_API_ TypedTestSuitePState {
   RegisteredTestsMap registered_tests_;
 };
 
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-using TypedTestCasePState = TypedTestSuitePState;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+using TypedTestCasePState = TypedTestSuitePState; 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
 // Skips to the first non-space char after the first comma in 'str';
 // returns NULL if no comma is found in 'str'.
 inline const char* SkipComma(const char* str) {
   const char* comma = strchr(str, ',');
-  if (comma == nullptr) {
-    return nullptr;
+  if (comma == nullptr) { 
+    return nullptr; 
   }
   while (IsSpace(*(++comma))) {}
   return comma;
@@ -662,7 +662,7 @@ inline const char* SkipComma(const char* str) {
 // the entire string if it contains no comma.
 inline std::string GetPrefixUntilComma(const char* str) {
   const char* comma = strchr(str, ',');
-  return comma == nullptr ? str : std::string(str, comma);
+  return comma == nullptr ? str : std::string(str, comma); 
 }
 
 // Splits a given string on a given delimiter, populating a given
@@ -670,37 +670,37 @@ inline std::string GetPrefixUntilComma(const char* str) {
 void SplitString(const ::std::string& str, char delimiter,
                  ::std::vector< ::std::string>* dest);
 
-// The default argument to the template below for the case when the user does
-// not provide a name generator.
-struct DefaultNameGenerator {
-  template <typename T>
-  static std::string GetName(int i) {
-    return StreamableToString(i);
-  }
-};
-
-template <typename Provided = DefaultNameGenerator>
-struct NameGeneratorSelector {
-  typedef Provided type;
-};
-
-template <typename NameGenerator>
-void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}
-
-template <typename NameGenerator, typename Types>
-void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
-  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
-  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
-                                          i + 1);
-}
-
-template <typename NameGenerator, typename Types>
-std::vector<std::string> GenerateNames() {
-  std::vector<std::string> result;
-  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
-  return result;
-}
-
+// The default argument to the template below for the case when the user does 
+// not provide a name generator. 
+struct DefaultNameGenerator { 
+  template <typename T> 
+  static std::string GetName(int i) { 
+    return StreamableToString(i); 
+  } 
+}; 
+ 
+template <typename Provided = DefaultNameGenerator> 
+struct NameGeneratorSelector { 
+  typedef Provided type; 
+}; 
+ 
+template <typename NameGenerator> 
+void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {} 
+ 
+template <typename NameGenerator, typename Types> 
+void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) { 
+  result->push_back(NameGenerator::template GetName<typename Types::Head>(i)); 
+  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result, 
+                                          i + 1); 
+} 
+ 
+template <typename NameGenerator, typename Types> 
+std::vector<std::string> GenerateNames() { 
+  std::vector<std::string> result; 
+  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0); 
+  return result; 
+} 
+ 
 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
 // registers a list of type-parameterized tests with Google Test.  The
 // return value is insignificant - we just need to return something
@@ -712,13 +712,13 @@ template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
 class TypeParameterizedTest {
  public:
   // 'index' is the index of the test in the type list 'Types'
-  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
+  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite, 
   // Types).  Valid values for 'index' are [0, N - 1] where N is the
   // length of Types.
-  static bool Register(const char* prefix, const CodeLocation& code_location,
-                       const char* case_name, const char* test_names, int index,
-                       const std::vector<std::string>& type_names =
-                           GenerateNames<DefaultNameGenerator, Types>()) {
+  static bool Register(const char* prefix, const CodeLocation& code_location, 
+                       const char* case_name, const char* test_names, int index, 
+                       const std::vector<std::string>& type_names = 
+                           GenerateNames<DefaultNameGenerator, Types>()) { 
     typedef typename Types::Head Type;
     typedef Fixture<Type> FixtureClass;
     typedef typename GTEST_BIND_(TestSel, Type) TestClass;
@@ -726,61 +726,61 @@ class TypeParameterizedTest {
     // First, registers the first type-parameterized test in the type
     // list.
     MakeAndRegisterTestInfo(
-        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
-         "/" + type_names[static_cast<size_t>(index)])
-            .c_str(),
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + 
+         "/" + type_names[static_cast<size_t>(index)]) 
+            .c_str(), 
         StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
         GetTypeName<Type>().c_str(),
-        nullptr,  // No value parameter.
-        code_location, GetTypeId<FixtureClass>(),
-        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
-            code_location.file.c_str(), code_location.line),
-        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
-            code_location.file.c_str(), code_location.line),
+        nullptr,  // No value parameter. 
+        code_location, GetTypeId<FixtureClass>(), 
+        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite( 
+            code_location.file.c_str(), code_location.line), 
+        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite( 
+            code_location.file.c_str(), code_location.line), 
         new TestFactoryImpl<TestClass>);
 
     // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel,
-                                 typename Types::Tail>::Register(prefix,
-                                                                 code_location,
-                                                                 case_name,
-                                                                 test_names,
-                                                                 index + 1,
-                                                                 type_names);
+    return TypeParameterizedTest<Fixture, TestSel, 
+                                 typename Types::Tail>::Register(prefix, 
+                                                                 code_location, 
+                                                                 case_name, 
+                                                                 test_names, 
+                                                                 index + 1, 
+                                                                 type_names); 
   }
 };
 
 // The base case for the compile time recursion.
 template <GTEST_TEMPLATE_ Fixture, class TestSel>
-class TypeParameterizedTest<Fixture, TestSel, internal::None> {
+class TypeParameterizedTest<Fixture, TestSel, internal::None> { 
  public:
-  static bool Register(const char* /*prefix*/, const CodeLocation&,
+  static bool Register(const char* /*prefix*/, const CodeLocation&, 
                        const char* /*case_name*/, const char* /*test_names*/,
-                       int /*index*/,
-                       const std::vector<std::string>& =
-                           std::vector<std::string>() /*type_names*/) {
+                       int /*index*/, 
+                       const std::vector<std::string>& = 
+                           std::vector<std::string>() /*type_names*/) { 
     return true;
   }
 };
 
-GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
-                                                   CodeLocation code_location);
-GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
-    const char* case_name);
-
-// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
+GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name, 
+                                                   CodeLocation code_location); 
+GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation( 
+    const char* case_name); 
+ 
+// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register() 
 // registers *all combinations* of 'Tests' and 'Types' with Google
 // Test.  The return value is insignificant - we just need to return
 // something such that we can call this function in a namespace scope.
 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
-class TypeParameterizedTestSuite {
+class TypeParameterizedTestSuite { 
  public:
   static bool Register(const char* prefix, CodeLocation code_location,
-                       const TypedTestSuitePState* state, const char* case_name,
-                       const char* test_names,
-                       const std::vector<std::string>& type_names =
-                           GenerateNames<DefaultNameGenerator, Types>()) {
-    RegisterTypeParameterizedTestSuiteInstantiation(case_name);
+                       const TypedTestSuitePState* state, const char* case_name, 
+                       const char* test_names, 
+                       const std::vector<std::string>& type_names = 
+                           GenerateNames<DefaultNameGenerator, Types>()) { 
+    RegisterTypeParameterizedTestSuiteInstantiation(case_name); 
     std::string test_name = StripTrailingSpaces(
         GetPrefixUntilComma(test_names));
     if (!state->TestExists(test_name)) {
@@ -797,26 +797,26 @@ class TypeParameterizedTestSuite {
 
     // First, register the first test in 'Test' for each type in 'Types'.
     TypeParameterizedTest<Fixture, Head, Types>::Register(
-        prefix, test_location, case_name, test_names, 0, type_names);
+        prefix, test_location, case_name, test_names, 0, type_names); 
 
     // Next, recurses (at compile time) with the tail of the test list.
-    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
-                                      Types>::Register(prefix, code_location,
-                                                       state, case_name,
-                                                       SkipComma(test_names),
-                                                       type_names);
+    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail, 
+                                      Types>::Register(prefix, code_location, 
+                                                       state, case_name, 
+                                                       SkipComma(test_names), 
+                                                       type_names); 
   }
 };
 
 // The base case for the compile time recursion.
 template <GTEST_TEMPLATE_ Fixture, typename Types>
-class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
+class TypeParameterizedTestSuite<Fixture, internal::None, Types> { 
  public:
-  static bool Register(const char* /*prefix*/, const CodeLocation&,
-                       const TypedTestSuitePState* /*state*/,
-                       const char* /*case_name*/, const char* /*test_names*/,
-                       const std::vector<std::string>& =
-                           std::vector<std::string>() /*type_names*/) {
+  static bool Register(const char* /*prefix*/, const CodeLocation&, 
+                       const TypedTestSuitePState* /*state*/, 
+                       const char* /*case_name*/, const char* /*test_names*/, 
+                       const std::vector<std::string>& = 
+                           std::vector<std::string>() /*type_names*/) { 
     return true;
   }
 };
@@ -852,16 +852,16 @@ struct GTEST_API_ ConstCharPtr {
   const char* value;
 };
 
-// Helper for declaring std::string within 'if' statement
-// in pre C++17 build environment.
-struct TrueWithString {
-  TrueWithString() = default;
-  explicit TrueWithString(const char* str) : value(str) {}
-  explicit TrueWithString(const std::string& str) : value(str) {}
-  explicit operator bool() const { return true; }
-  std::string value;
-};
-
+// Helper for declaring std::string within 'if' statement 
+// in pre C++17 build environment. 
+struct TrueWithString { 
+  TrueWithString() = default; 
+  explicit TrueWithString(const char* str) : value(str) {} 
+  explicit TrueWithString(const std::string& str) : value(str) {} 
+  explicit operator bool() const { return true; } 
+  std::string value; 
+}; 
+ 
 // A simple Linear Congruential Generator for generating random
 // numbers with a uniform distribution.  Unlike rand() and srand(), it
 // doesn't use global state (and therefore can't interfere with user
@@ -869,51 +869,51 @@ struct TrueWithString {
 // but it's good enough for our purposes.
 class GTEST_API_ Random {
  public:
-  static const uint32_t kMaxRange = 1u << 31;
+  static const uint32_t kMaxRange = 1u << 31; 
 
-  explicit Random(uint32_t seed) : state_(seed) {}
+  explicit Random(uint32_t seed) : state_(seed) {} 
 
-  void Reseed(uint32_t seed) { state_ = seed; }
+  void Reseed(uint32_t seed) { state_ = seed; } 
 
   // Generates a random number from [0, range).  Crashes if 'range' is
   // 0 or greater than kMaxRange.
-  uint32_t Generate(uint32_t range);
+  uint32_t Generate(uint32_t range); 
 
  private:
-  uint32_t state_;
+  uint32_t state_; 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
 };
 
 // Turns const U&, U&, const U, and U all into U.
 #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
-  typename std::remove_const<typename std::remove_reference<T>::type>::type
+  typename std::remove_const<typename std::remove_reference<T>::type>::type 
 
-// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant
-// that's true if and only if T has methods DebugString() and ShortDebugString()
+// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant 
+// that's true if and only if T has methods DebugString() and ShortDebugString() 
 template <typename T>
-class HasDebugStringAndShortDebugString {
- private:
-  template<typename C>
-  static std::true_type CheckDebugString(decltype(&C::DebugString));
-  template<typename>
-  static std::false_type CheckDebugString(...);
-
-  template<typename C>
-  static std::true_type CheckShortDebugString(decltype(&C::ShortDebugString));
-  template <typename>
-  static std::false_type CheckShortDebugString(...);
-
-  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr));
-  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr));
-
- public:
-  static constexpr bool value =
-      HasDebugStringType::value && HasShortDebugStringType::value;
-};
-
-template <typename T>
-constexpr bool HasDebugStringAndShortDebugString<T>::value;
-
+class HasDebugStringAndShortDebugString { 
+ private: 
+  template<typename C> 
+  static std::true_type CheckDebugString(decltype(&C::DebugString)); 
+  template<typename> 
+  static std::false_type CheckDebugString(...); 
+
+  template<typename C> 
+  static std::true_type CheckShortDebugString(decltype(&C::ShortDebugString)); 
+  template <typename> 
+  static std::false_type CheckShortDebugString(...); 
+ 
+  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr)); 
+  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr)); 
+ 
+ public: 
+  static constexpr bool value = 
+      HasDebugStringType::value && HasShortDebugStringType::value; 
+}; 
+ 
+template <typename T> 
+constexpr bool HasDebugStringAndShortDebugString<T>::value; 
+ 
 // When the compiler sees expression IsContainerTest<C>(0), if C is an
 // STL-style container class, the first overload of IsContainerTest
 // will be viable (since both C::iterator* and C::const_iterator* are
@@ -925,11 +925,11 @@ constexpr bool HasDebugStringAndShortDebugString<T>::value;
 // a container class by checking the type of IsContainerTest<C>(0).
 // The value of the expression is insignificant.
 //
-// In C++11 mode we check the existence of a const_iterator and that an
-// iterator is properly implemented for the container.
-//
-// For pre-C++11 that we look for both C::iterator and C::const_iterator.
-// The reason is that C++ injects the name of a class as a member of the
+// In C++11 mode we check the existence of a const_iterator and that an 
+// iterator is properly implemented for the container. 
+// 
+// For pre-C++11 that we look for both C::iterator and C::const_iterator. 
+// The reason is that C++ injects the name of a class as a member of the 
 // class itself (e.g. you can refer to class iterator as either
 // 'iterator' or 'iterator::iterator').  If we look for C::iterator
 // only, for example, we would mistakenly think that a class named
@@ -939,13 +939,13 @@ constexpr bool HasDebugStringAndShortDebugString<T>::value;
 // IsContainerTest(typename C::const_iterator*) and
 // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
 typedef int IsContainer;
-template <class C,
-          class Iterator = decltype(::std::declval<const C&>().begin()),
-          class = decltype(::std::declval<const C&>().end()),
-          class = decltype(++::std::declval<Iterator&>()),
-          class = decltype(*::std::declval<Iterator>()),
-          class = typename C::const_iterator>
-IsContainer IsContainerTest(int /* dummy */) {
+template <class C, 
+          class Iterator = decltype(::std::declval<const C&>().begin()), 
+          class = decltype(::std::declval<const C&>().end()), 
+          class = decltype(++::std::declval<Iterator&>()), 
+          class = decltype(*::std::declval<Iterator>()), 
+          class = typename C::const_iterator> 
+IsContainer IsContainerTest(int /* dummy */) { 
   return 0;
 }
 
@@ -953,56 +953,56 @@ typedef char IsNotContainer;
 template <class C>
 IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
 
-// Trait to detect whether a type T is a hash table.
-// The heuristic used is that the type contains an inner type `hasher` and does
-// not contain an inner type `reverse_iterator`.
-// If the container is iterable in reverse, then order might actually matter.
-template <typename T>
-struct IsHashTable {
- private:
-  template <typename U>
-  static char test(typename U::hasher*, typename U::reverse_iterator*);
-  template <typename U>
-  static int test(typename U::hasher*, ...);
-  template <typename U>
-  static char test(...);
-
- public:
-  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
-};
-
-template <typename T>
-const bool IsHashTable<T>::value;
-
-template <typename C,
-          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
-struct IsRecursiveContainerImpl;
-
-template <typename C>
-struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
-
-// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
-// obey the same inconsistencies as the IsContainerTest, namely check if
-// something is a container is relying on only const_iterator in C++11 and
-// is relying on both const_iterator and iterator otherwise
-template <typename C>
-struct IsRecursiveContainerImpl<C, true> {
-  using value_type = decltype(*std::declval<typename C::const_iterator>());
-  using type =
-      std::is_same<typename std::remove_const<
-                       typename std::remove_reference<value_type>::type>::type,
-                   C>;
-};
-
-// IsRecursiveContainer<Type> is a unary compile-time predicate that
-// evaluates whether C is a recursive container type. A recursive container
-// type is a container type whose value_type is equal to the container type
-// itself. An example for a recursive container type is
-// boost::filesystem::path, whose iterator has a value_type that is equal to
-// boost::filesystem::path.
-template <typename C>
-struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
-
+// Trait to detect whether a type T is a hash table. 
+// The heuristic used is that the type contains an inner type `hasher` and does 
+// not contain an inner type `reverse_iterator`. 
+// If the container is iterable in reverse, then order might actually matter. 
+template <typename T> 
+struct IsHashTable { 
+ private: 
+  template <typename U> 
+  static char test(typename U::hasher*, typename U::reverse_iterator*); 
+  template <typename U> 
+  static int test(typename U::hasher*, ...); 
+  template <typename U> 
+  static char test(...); 
+
+ public: 
+  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int); 
+}; 
+ 
+template <typename T> 
+const bool IsHashTable<T>::value; 
+ 
+template <typename C, 
+          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)> 
+struct IsRecursiveContainerImpl; 
+ 
+template <typename C> 
+struct IsRecursiveContainerImpl<C, false> : public std::false_type {}; 
+ 
+// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to 
+// obey the same inconsistencies as the IsContainerTest, namely check if 
+// something is a container is relying on only const_iterator in C++11 and 
+// is relying on both const_iterator and iterator otherwise 
+template <typename C> 
+struct IsRecursiveContainerImpl<C, true> { 
+  using value_type = decltype(*std::declval<typename C::const_iterator>()); 
+  using type = 
+      std::is_same<typename std::remove_const< 
+                       typename std::remove_reference<value_type>::type>::type, 
+                   C>; 
+}; 
+ 
+// IsRecursiveContainer<Type> is a unary compile-time predicate that 
+// evaluates whether C is a recursive container type. A recursive container 
+// type is a container type whose value_type is equal to the container type 
+// itself. An example for a recursive container type is 
+// boost::filesystem::path, whose iterator has a value_type that is equal to 
+// boost::filesystem::path. 
+template <typename C> 
+struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {}; 
+ 
 // Utilities for native arrays.
 
 // ArrayEq() compares two k-dimensional native arrays using the
@@ -1125,9 +1125,9 @@ class NativeArray {
   }
 
  private:
-  static_assert(!std::is_const<Element>::value, "Type must not be const");
-  static_assert(!std::is_reference<Element>::value,
-                "Type must not be a reference");
+  static_assert(!std::is_const<Element>::value, "Type must not be const"); 
+  static_assert(!std::is_reference<Element>::value, 
+                "Type must not be a reference"); 
 
   // Initializes this object with a copy of the input.
   void InitCopy(const Element* array, size_t a_size) {
@@ -1150,188 +1150,188 @@ class NativeArray {
   void (NativeArray::*clone_)(const Element*, size_t);
 };
 
-// Backport of std::index_sequence.
-template <size_t... Is>
-struct IndexSequence {
-  using type = IndexSequence;
-};
-
-// Double the IndexSequence, and one if plus_one is true.
-template <bool plus_one, typename T, size_t sizeofT>
-struct DoubleSequence;
-template <size_t... I, size_t sizeofT>
-struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
-  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
-};
-template <size_t... I, size_t sizeofT>
-struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
-  using type = IndexSequence<I..., (sizeofT + I)...>;
-};
-
-// Backport of std::make_index_sequence.
-// It uses O(ln(N)) instantiation depth.
-template <size_t N>
-struct MakeIndexSequenceImpl
-    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
-                     N / 2>::type {};
-
-template <>
-struct MakeIndexSequenceImpl<0> : IndexSequence<> {};
-
-template <size_t N>
-using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
-
-template <typename... T>
-using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;
-
-template <size_t>
-struct Ignore {
-  Ignore(...);  // NOLINT
-};
-
-template <typename>
-struct ElemFromListImpl;
-template <size_t... I>
-struct ElemFromListImpl<IndexSequence<I...>> {
-  // We make Ignore a template to solve a problem with MSVC.
-  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
-  // MSVC doesn't understand how to deal with that pack expansion.
-  // Use `0 * I` to have a single instantiation of Ignore.
-  template <typename R>
-  static R Apply(Ignore<0 * I>..., R (*)(), ...);
-};
-
-template <size_t N, typename... T>
-struct ElemFromList {
-  using type =
-      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
-          static_cast<T (*)()>(nullptr)...));
-};
-
-struct FlatTupleConstructTag {};
-
-template <typename... T>
-class FlatTuple;
-
-template <typename Derived, size_t I>
-struct FlatTupleElemBase;
-
-template <typename... T, size_t I>
-struct FlatTupleElemBase<FlatTuple<T...>, I> {
-  using value_type = typename ElemFromList<I, T...>::type;
-  FlatTupleElemBase() = default;
-  template <typename Arg>
-  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t)
-      : value(std::forward<Arg>(t)) {}
-  value_type value;
-};
-
-template <typename Derived, typename Idx>
-struct FlatTupleBase;
-
-template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
-    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
-  using Indices = IndexSequence<Idx...>;
-  FlatTupleBase() = default;
-  template <typename... Args>
-  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
-      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{},
-                                                std::forward<Args>(args))... {}
-
-  template <size_t I>
-  const typename ElemFromList<I, T...>::type& Get() const {
-    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
-  }
-
-  template <size_t I>
-  typename ElemFromList<I, T...>::type& Get() {
-    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
-  }
-
-  template <typename F>
-  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
-    return std::forward<F>(f)(Get<Idx>()...);
-  }
-
-  template <typename F>
-  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
-    return std::forward<F>(f)(Get<Idx>()...);
-  }
-};
-
-// Analog to std::tuple but with different tradeoffs.
-// This class minimizes the template instantiation depth, thus allowing more
-// elements than std::tuple would. std::tuple has been seen to require an
-// instantiation depth of more than 10x the number of elements in some
-// implementations.
-// FlatTuple and ElemFromList are not recursive and have a fixed depth
-// regardless of T...
-// MakeIndexSequence, on the other hand, it is recursive but with an
-// instantiation depth of O(ln(N)).
-template <typename... T>
-class FlatTuple
-    : private FlatTupleBase<FlatTuple<T...>,
-                            typename MakeIndexSequence<sizeof...(T)>::type> {
-  using Indices = typename FlatTupleBase<
-      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;
-
- public:
-  FlatTuple() = default;
-  template <typename... Args>
-  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
-      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
-
-  using FlatTuple::FlatTupleBase::Apply;
-  using FlatTuple::FlatTupleBase::Get;
-};
-
-// Utility functions to be called with static_assert to induce deprecation
-// warnings.
-GTEST_INTERNAL_DEPRECATED(
-    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TEST_SUITE_P")
-constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "TYPED_TEST_CASE_P is deprecated, please use "
-    "TYPED_TEST_SUITE_P")
-constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "TYPED_TEST_CASE is deprecated, please use "
-    "TYPED_TEST_SUITE")
-constexpr bool TypedTestCaseIsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
-    "REGISTER_TYPED_TEST_SUITE_P")
-constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
-
-GTEST_INTERNAL_DEPRECATED(
-    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TYPED_TEST_SUITE_P")
-constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
-
+// Backport of std::index_sequence. 
+template <size_t... Is> 
+struct IndexSequence { 
+  using type = IndexSequence; 
+}; 
+ 
+// Double the IndexSequence, and one if plus_one is true. 
+template <bool plus_one, typename T, size_t sizeofT> 
+struct DoubleSequence; 
+template <size_t... I, size_t sizeofT> 
+struct DoubleSequence<true, IndexSequence<I...>, sizeofT> { 
+  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>; 
+}; 
+template <size_t... I, size_t sizeofT> 
+struct DoubleSequence<false, IndexSequence<I...>, sizeofT> { 
+  using type = IndexSequence<I..., (sizeofT + I)...>; 
+}; 
+ 
+// Backport of std::make_index_sequence. 
+// It uses O(ln(N)) instantiation depth. 
+template <size_t N> 
+struct MakeIndexSequenceImpl 
+    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type, 
+                     N / 2>::type {}; 
+ 
+template <> 
+struct MakeIndexSequenceImpl<0> : IndexSequence<> {}; 
+ 
+template <size_t N> 
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type; 
+ 
+template <typename... T> 
+using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type; 
+ 
+template <size_t> 
+struct Ignore { 
+  Ignore(...);  // NOLINT 
+}; 
+ 
+template <typename> 
+struct ElemFromListImpl; 
+template <size_t... I> 
+struct ElemFromListImpl<IndexSequence<I...>> { 
+  // We make Ignore a template to solve a problem with MSVC. 
+  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but 
+  // MSVC doesn't understand how to deal with that pack expansion. 
+  // Use `0 * I` to have a single instantiation of Ignore. 
+  template <typename R> 
+  static R Apply(Ignore<0 * I>..., R (*)(), ...); 
+}; 
+ 
+template <size_t N, typename... T> 
+struct ElemFromList { 
+  using type = 
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply( 
+          static_cast<T (*)()>(nullptr)...)); 
+}; 
+ 
+struct FlatTupleConstructTag {}; 
+ 
+template <typename... T> 
+class FlatTuple; 
+ 
+template <typename Derived, size_t I> 
+struct FlatTupleElemBase; 
+ 
+template <typename... T, size_t I> 
+struct FlatTupleElemBase<FlatTuple<T...>, I> { 
+  using value_type = typename ElemFromList<I, T...>::type; 
+  FlatTupleElemBase() = default; 
+  template <typename Arg> 
+  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t) 
+      : value(std::forward<Arg>(t)) {} 
+  value_type value; 
+}; 
+ 
+template <typename Derived, typename Idx> 
+struct FlatTupleBase; 
+ 
+template <size_t... Idx, typename... T> 
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>> 
+    : FlatTupleElemBase<FlatTuple<T...>, Idx>... { 
+  using Indices = IndexSequence<Idx...>; 
+  FlatTupleBase() = default; 
+  template <typename... Args> 
+  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args) 
+      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{}, 
+                                                std::forward<Args>(args))... {} 
+ 
+  template <size_t I> 
+  const typename ElemFromList<I, T...>::type& Get() const { 
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value; 
+  } 
+ 
+  template <size_t I> 
+  typename ElemFromList<I, T...>::type& Get() { 
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value; 
+  } 
+ 
+  template <typename F> 
+  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) { 
+    return std::forward<F>(f)(Get<Idx>()...); 
+  } 
+ 
+  template <typename F> 
+  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) { 
+    return std::forward<F>(f)(Get<Idx>()...); 
+  } 
+}; 
+ 
+// Analog to std::tuple but with different tradeoffs. 
+// This class minimizes the template instantiation depth, thus allowing more 
+// elements than std::tuple would. std::tuple has been seen to require an 
+// instantiation depth of more than 10x the number of elements in some 
+// implementations. 
+// FlatTuple and ElemFromList are not recursive and have a fixed depth 
+// regardless of T... 
+// MakeIndexSequence, on the other hand, it is recursive but with an 
+// instantiation depth of O(ln(N)). 
+template <typename... T> 
+class FlatTuple 
+    : private FlatTupleBase<FlatTuple<T...>, 
+                            typename MakeIndexSequence<sizeof...(T)>::type> { 
+  using Indices = typename FlatTupleBase< 
+      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices; 
+ 
+ public: 
+  FlatTuple() = default; 
+  template <typename... Args> 
+  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args) 
+      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {} 
+ 
+  using FlatTuple::FlatTupleBase::Apply; 
+  using FlatTuple::FlatTupleBase::Get; 
+}; 
+ 
+// Utility functions to be called with static_assert to induce deprecation 
+// warnings. 
+GTEST_INTERNAL_DEPRECATED( 
+    "INSTANTIATE_TEST_CASE_P is deprecated, please use " 
+    "INSTANTIATE_TEST_SUITE_P") 
+constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; } 
+ 
+GTEST_INTERNAL_DEPRECATED( 
+    "TYPED_TEST_CASE_P is deprecated, please use " 
+    "TYPED_TEST_SUITE_P") 
+constexpr bool TypedTestCase_P_IsDeprecated() { return true; } 
+ 
+GTEST_INTERNAL_DEPRECATED( 
+    "TYPED_TEST_CASE is deprecated, please use " 
+    "TYPED_TEST_SUITE") 
+constexpr bool TypedTestCaseIsDeprecated() { return true; } 
+ 
+GTEST_INTERNAL_DEPRECATED( 
+    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use " 
+    "REGISTER_TYPED_TEST_SUITE_P") 
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; } 
+ 
+GTEST_INTERNAL_DEPRECATED( 
+    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use " 
+    "INSTANTIATE_TYPED_TEST_SUITE_P") 
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; } 
+ 
 }  // namespace internal
 }  // namespace testing
 
-namespace std {
-// Some standard library implementations use `struct tuple_size` and some use
-// `class tuple_size`. Clang warns about the mismatch.
-// https://reviews.llvm.org/D55466
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmismatched-tags"
-#endif
-template <typename... Ts>
-struct tuple_size<testing::internal::FlatTuple<Ts...>>
-    : std::integral_constant<size_t, sizeof...(Ts)> {};
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-}  // namespace std
-
+namespace std { 
+// Some standard library implementations use `struct tuple_size` and some use 
+// `class tuple_size`. Clang warns about the mismatch. 
+// https://reviews.llvm.org/D55466 
+#ifdef __clang__ 
+#pragma clang diagnostic push 
+#pragma clang diagnostic ignored "-Wmismatched-tags" 
+#endif 
+template <typename... Ts> 
+struct tuple_size<testing::internal::FlatTuple<Ts...>> 
+    : std::integral_constant<size_t, sizeof...(Ts)> {}; 
+#ifdef __clang__ 
+#pragma clang diagnostic pop 
+#endif 
+}  // namespace std 
+ 
 #define GTEST_MESSAGE_AT_(file, line, message, result_type) \
   ::testing::internal::AssertHelper(result_type, file, line, message) \
     = ::testing::Message()
@@ -1348,128 +1348,128 @@ struct tuple_size<testing::internal::FlatTuple<Ts...>>
 #define GTEST_SUCCESS_(message) \
   GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
 
-#define GTEST_SKIP_(message) \
-  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
-
-// Suppress MSVC warning 4072 (unreachable code) for the code following
+#define GTEST_SKIP_(message) \ 
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip) 
+ 
+// Suppress MSVC warning 4072 (unreachable code) for the code following 
 // statement if it returns or throws (or doesn't return or throw in some
 // situations).
-// NOTE: The "else" is important to keep this expansion to prevent a top-level
-// "else" from attaching to our "if".
+// NOTE: The "else" is important to keep this expansion to prevent a top-level 
+// "else" from attaching to our "if". 
 #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
-  if (::testing::internal::AlwaysTrue()) {                        \
-    statement;                                                    \
-  } else                     /* NOLINT */                         \
-    static_assert(true, "")  // User must have a semicolon after expansion.
-
-#if GTEST_HAS_EXCEPTIONS
-
-namespace testing {
-namespace internal {
-
-class NeverThrown {
- public:
-  const char* what() const noexcept {
-    return "this exception should never be thrown";
-  }
-};
-
-}  // namespace internal
-}  // namespace testing
-
-#if GTEST_HAS_RTTI
-
-#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
-
-#else  // GTEST_HAS_RTTI
-
-#define GTEST_EXCEPTION_TYPE_(e) \
-  std::string { "an std::exception-derived error" }
-
-#endif  // GTEST_HAS_RTTI
-
-#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \
-  catch (typename std::conditional<                                            \
-         std::is_same<typename std::remove_cv<typename std::remove_reference<  \
-                          expected_exception>::type>::type,                    \
-                      std::exception>::value,                                  \
-         const ::testing::internal::NeverThrown&, const std::exception&>::type \
-             e) {                                                              \
-    gtest_msg.value = "Expected: " #statement                                  \
-                      " throws an exception of type " #expected_exception      \
-                      ".\n  Actual: it throws ";                               \
-    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \
-    gtest_msg.value += " with description \"";                                 \
-    gtest_msg.value += e.what();                                               \
-    gtest_msg.value += "\".";                                                  \
-    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \
-  }
-
-#else  // GTEST_HAS_EXCEPTIONS
-
-#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
-#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \
-  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
-  if (::testing::internal::TrueWithString gtest_msg{}) {                    \
-    bool gtest_caught_expected = false;                                     \
-    try {                                                                   \
-      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \
-    } catch (expected_exception const&) {                                   \
-      gtest_caught_expected = true;                                         \
-    }                                                                       \
-    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \
-    catch (...) {                                                           \
-      gtest_msg.value = "Expected: " #statement                             \
-                        " throws an exception of type " #expected_exception \
-                        ".\n  Actual: it throws a different type.";         \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
-    }                                                                       \
-    if (!gtest_caught_expected) {                                           \
-      gtest_msg.value = "Expected: " #statement                             \
-                        " throws an exception of type " #expected_exception \
-                        ".\n  Actual: it throws nothing.";                  \
-      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
-    }                                                                       \
-  } else /*NOLINT*/                                                         \
-    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \
-        : fail(gtest_msg.value.c_str())
-
-#if GTEST_HAS_EXCEPTIONS
-
-#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \
-  catch (std::exception const& e) {                               \
-    gtest_msg.value = "it throws ";                               \
-    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \
-    gtest_msg.value += " with description \"";                    \
-    gtest_msg.value += e.what();                                  \
-    gtest_msg.value += "\".";                                     \
-    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
-  }
-
-#else  // GTEST_HAS_EXCEPTIONS
-
-#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
-
-#endif  // GTEST_HAS_EXCEPTIONS
-
+  if (::testing::internal::AlwaysTrue()) {                        \ 
+    statement;                                                    \ 
+  } else                     /* NOLINT */                         \ 
+    static_assert(true, "")  // User must have a semicolon after expansion. 
+
+#if GTEST_HAS_EXCEPTIONS 
+
+namespace testing { 
+namespace internal { 
+ 
+class NeverThrown { 
+ public: 
+  const char* what() const noexcept { 
+    return "this exception should never be thrown"; 
+  } 
+}; 
+ 
+}  // namespace internal 
+}  // namespace testing 
+ 
+#if GTEST_HAS_RTTI 
+ 
+#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e)) 
+ 
+#else  // GTEST_HAS_RTTI 
+ 
+#define GTEST_EXCEPTION_TYPE_(e) \ 
+  std::string { "an std::exception-derived error" } 
+ 
+#endif  // GTEST_HAS_RTTI 
+ 
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \ 
+  catch (typename std::conditional<                                            \ 
+         std::is_same<typename std::remove_cv<typename std::remove_reference<  \ 
+                          expected_exception>::type>::type,                    \ 
+                      std::exception>::value,                                  \ 
+         const ::testing::internal::NeverThrown&, const std::exception&>::type \ 
+             e) {                                                              \ 
+    gtest_msg.value = "Expected: " #statement                                  \ 
+                      " throws an exception of type " #expected_exception      \ 
+                      ".\n  Actual: it throws ";                               \ 
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \ 
+    gtest_msg.value += " with description \"";                                 \ 
+    gtest_msg.value += e.what();                                               \ 
+    gtest_msg.value += "\".";                                                  \ 
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \ 
+  } 
+ 
+#else  // GTEST_HAS_EXCEPTIONS 
+ 
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception) 
+ 
+#endif  // GTEST_HAS_EXCEPTIONS 
+ 
+#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \ 
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \ 
+  if (::testing::internal::TrueWithString gtest_msg{}) {                    \ 
+    bool gtest_caught_expected = false;                                     \ 
+    try {                                                                   \ 
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \ 
+    } catch (expected_exception const&) {                                   \ 
+      gtest_caught_expected = true;                                         \ 
+    }                                                                       \ 
+    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \ 
+    catch (...) {                                                           \ 
+      gtest_msg.value = "Expected: " #statement                             \ 
+                        " throws an exception of type " #expected_exception \ 
+                        ".\n  Actual: it throws a different type.";         \ 
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \ 
+    }                                                                       \ 
+    if (!gtest_caught_expected) {                                           \ 
+      gtest_msg.value = "Expected: " #statement                             \ 
+                        " throws an exception of type " #expected_exception \ 
+                        ".\n  Actual: it throws nothing.";                  \ 
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \ 
+    }                                                                       \ 
+  } else /*NOLINT*/                                                         \ 
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \ 
+        : fail(gtest_msg.value.c_str()) 
+ 
+#if GTEST_HAS_EXCEPTIONS 
+ 
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \ 
+  catch (std::exception const& e) {                               \ 
+    gtest_msg.value = "it throws ";                               \ 
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \ 
+    gtest_msg.value += " with description \"";                    \ 
+    gtest_msg.value += e.what();                                  \ 
+    gtest_msg.value += "\".";                                     \ 
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ 
+  } 
+ 
+#else  // GTEST_HAS_EXCEPTIONS 
+ 
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() 
+ 
+#endif  // GTEST_HAS_EXCEPTIONS 
+ 
 #define GTEST_TEST_NO_THROW_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
-  if (::testing::internal::TrueWithString gtest_msg{}) { \
+  if (::testing::internal::TrueWithString gtest_msg{}) { \ 
     try { \
       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
     } \
-    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
+    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \ 
     catch (...) { \
-      gtest_msg.value = "it throws."; \
+      gtest_msg.value = "it throws."; \ 
       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
     } \
   } else \
     GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
-      fail(("Expected: " #statement " doesn't throw an exception.\n" \
-            "  Actual: " + gtest_msg.value).c_str())
+      fail(("Expected: " #statement " doesn't throw an exception.\n" \ 
+            "  Actual: " + gtest_msg.value).c_str()) 
 
 #define GTEST_TEST_ANY_THROW_(statement, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
@@ -1492,7 +1492,7 @@ class NeverThrown {
 
 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
 // either a boolean expression or an AssertionResult. text is a textual
-// representation of expression as it was passed into the EXPECT_TRUE.
+// representation of expression as it was passed into the EXPECT_TRUE. 
 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
   if (const ::testing::AssertionResult gtest_ar_ = \
@@ -1517,41 +1517,41 @@ class NeverThrown {
            "  Actual: it does.")
 
 // Expands to the name of the class that implements the given test.
-#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
-  test_suite_name##_##test_name##_Test
+#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \ 
+  test_suite_name##_##test_name##_Test 
 
 // Helper macro for defining tests.
-#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
-  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
-                "test_suite_name must not be empty");                         \
-  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
-                "test_name must not be empty");                               \
-  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
-      : public parent_class {                                                 \
-   public:                                                                    \
-    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
-    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
-    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
-                                                           test_name));       \
-    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
-                                                           test_name));       \
-                                                                              \
-   private:                                                                   \
-    void TestBody() override;                                                 \
-    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
-  };                                                                          \
-                                                                              \
-  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
-                                                    test_name)::test_info_ =  \
-      ::testing::internal::MakeAndRegisterTestInfo(                           \
-          #test_suite_name, #test_name, nullptr, nullptr,                     \
-          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
-          ::testing::internal::SuiteApiResolver<                              \
-              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
-          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
-              test_suite_name, test_name)>);                                  \
-  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
-
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \ 
+  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \ 
+                "test_suite_name must not be empty");                         \ 
+  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \ 
+                "test_name must not be empty");                               \ 
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \ 
+      : public parent_class {                                                 \ 
+   public:                                                                    \ 
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \ 
+    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \ 
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \ 
+                                                           test_name));       \ 
+    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \ 
+                                                           test_name));       \ 
+                                                                              \ 
+   private:                                                                   \ 
+    void TestBody() override;                                                 \ 
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \ 
+  };                                                                          \ 
+                                                                              \ 
+  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \ 
+                                                    test_name)::test_info_ =  \ 
+      ::testing::internal::MakeAndRegisterTestInfo(                           \ 
+          #test_suite_name, #test_name, nullptr, nullptr,                     \ 
+          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \ 
+          ::testing::internal::SuiteApiResolver<                              \ 
+              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \ 
+          ::testing::internal::SuiteApiResolver<                              \ 
+              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \ 
+          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \ 
+              test_suite_name, test_name)>);                                  \ 
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody() 
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-param-util.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-param-util.h
index c2ef6e3124..6ed659d780 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-param-util.h
@@ -27,29 +27,29 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 // Type and function utilities for implementing parameterized tests.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 
 
 #include <ctype.h>
 
-#include <cassert>
+#include <cassert> 
 #include <iterator>
-#include <memory>
+#include <memory> 
 #include <set>
-#include <tuple>
-#include <type_traits>
+#include <tuple> 
+#include <type_traits> 
 #include <utility>
 #include <vector>
 
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-port.h"
 #include "gtest/gtest-printers.h"
-#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-test-part.h" 
 
 namespace testing {
 // Input to a parameterized test name generator, describing a test parameter.
@@ -75,14 +75,14 @@ struct PrintToStringParamName {
 namespace internal {
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-// Utility Functions
-
+// Utility Functions 
+ 
 // Outputs a message explaining invalid registration of different
-// fixture class for the same test suite. This may happen when
+// fixture class for the same test suite. This may happen when 
 // TEST_P macro is used to define two tests with the same name
 // but in different namespaces.
-GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                           CodeLocation code_location);
+GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name, 
+                                           CodeLocation code_location); 
 
 template <typename> class ParamGeneratorInterface;
 template <typename> class ParamGenerator;
@@ -157,7 +157,7 @@ class ParamIterator {
  private:
   friend class ParamGenerator<T>;
   explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
-  std::unique_ptr<ParamIteratorInterface<T> > impl_;
+  std::unique_ptr<ParamIteratorInterface<T> > impl_; 
 };
 
 // ParamGeneratorInterface<T> is the binary interface to access generators
@@ -196,7 +196,7 @@ class ParamGenerator {
   iterator end() const { return iterator(impl_->End()); }
 
  private:
-  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
+  std::shared_ptr<const ParamGeneratorInterface<T> > impl_; 
 };
 
 // Generates values from a range of two comparable values. Can be used to
@@ -209,12 +209,12 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
   RangeGenerator(T begin, T end, IncrementT step)
       : begin_(begin), end_(end),
         step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
-  ~RangeGenerator() override {}
+  ~RangeGenerator() override {} 
 
-  ParamIteratorInterface<T>* Begin() const override {
+  ParamIteratorInterface<T>* Begin() const override { 
     return new Iterator(this, begin_, 0, step_);
   }
-  ParamIteratorInterface<T>* End() const override {
+  ParamIteratorInterface<T>* End() const override { 
     return new Iterator(this, end_, end_index_, step_);
   }
 
@@ -224,20 +224,20 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
     Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
              IncrementT step)
         : base_(base), value_(value), index_(index), step_(step) {}
-    ~Iterator() override {}
+    ~Iterator() override {} 
 
-    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+    const ParamGeneratorInterface<T>* BaseGenerator() const override { 
       return base_;
     }
-    void Advance() override {
+    void Advance() override { 
       value_ = static_cast<T>(value_ + step_);
       index_++;
     }
-    ParamIteratorInterface<T>* Clone() const override {
+    ParamIteratorInterface<T>* Clone() const override { 
       return new Iterator(*this);
     }
-    const T* Current() const override { return &value_; }
-    bool Equals(const ParamIteratorInterface<T>& other) const override {
+    const T* Current() const override { return &value_; } 
+    bool Equals(const ParamIteratorInterface<T>& other) const override { 
       // Having the same base generator guarantees that the other
       // iterator is of the same type and we can downcast.
       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
@@ -294,12 +294,12 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
   template <typename ForwardIterator>
   ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
       : container_(begin, end) {}
-  ~ValuesInIteratorRangeGenerator() override {}
+  ~ValuesInIteratorRangeGenerator() override {} 
 
-  ParamIteratorInterface<T>* Begin() const override {
+  ParamIteratorInterface<T>* Begin() const override { 
     return new Iterator(this, container_.begin());
   }
-  ParamIteratorInterface<T>* End() const override {
+  ParamIteratorInterface<T>* End() const override { 
     return new Iterator(this, container_.end());
   }
 
@@ -311,16 +311,16 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
     Iterator(const ParamGeneratorInterface<T>* base,
              typename ContainerType::const_iterator iterator)
         : base_(base), iterator_(iterator) {}
-    ~Iterator() override {}
+    ~Iterator() override {} 
 
-    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+    const ParamGeneratorInterface<T>* BaseGenerator() const override { 
       return base_;
     }
-    void Advance() override {
+    void Advance() override { 
       ++iterator_;
       value_.reset();
     }
-    ParamIteratorInterface<T>* Clone() const override {
+    ParamIteratorInterface<T>* Clone() const override { 
       return new Iterator(*this);
     }
     // We need to use cached value referenced by iterator_ because *iterator_
@@ -330,11 +330,11 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
     // can advance iterator_ beyond the end of the range, and we cannot
     // detect that fact. The client code, on the other hand, is
     // responsible for not calling Current() on an out-of-range iterator.
-    const T* Current() const override {
-      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
+    const T* Current() const override { 
+      if (value_.get() == nullptr) value_.reset(new T(*iterator_)); 
       return value_.get();
     }
-    bool Equals(const ParamIteratorInterface<T>& other) const override {
+    bool Equals(const ParamIteratorInterface<T>& other) const override { 
       // Having the same base generator guarantees that the other
       // iterator is of the same type and we can downcast.
       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
@@ -357,9 +357,9 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
     // A cached value of *iterator_. We keep it here to allow access by
     // pointer in the wrapping iterator's operator->().
     // value_ needs to be mutable to be accessed in Current().
-    // Use of std::unique_ptr helps manage cached value's lifetime,
+    // Use of std::unique_ptr helps manage cached value's lifetime, 
     // which is bound by the lifespan of the iterator itself.
-    mutable std::unique_ptr<const T> value_;
+    mutable std::unique_ptr<const T> value_; 
   };  // class ValuesInIteratorRangeGenerator::Iterator
 
   // No implementation - assignment is unsupported.
@@ -379,12 +379,12 @@ std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
   return name_stream.GetString();
 }
 
-template <typename T = int>
-void TestNotEmpty() {
-  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
+template <typename T = int> 
+void TestNotEmpty() { 
+  static_assert(sizeof(T) == 0, "Empty arguments are not allowed."); 
 }
-template <typename T = int>
-void TestNotEmpty(const T&) {}
+template <typename T = int> 
+void TestNotEmpty(const T&) {} 
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
@@ -396,7 +396,7 @@ class ParameterizedTestFactory : public TestFactoryBase {
   typedef typename TestClass::ParamType ParamType;
   explicit ParameterizedTestFactory(ParamType parameter) :
       parameter_(parameter) {}
-  Test* CreateTest() override {
+  Test* CreateTest() override { 
     TestClass::SetParam(&parameter_);
     return new TestClass();
   }
@@ -424,19 +424,19 @@ class TestMetaFactoryBase {
 // TestMetaFactory creates test factories for passing into
 // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
 // ownership of test factory pointer, same factory object cannot be passed
-// into that method twice. But ParameterizedTestSuiteInfo is going to call
+// into that method twice. But ParameterizedTestSuiteInfo is going to call 
 // it for each Test/Parameter value combination. Thus it needs meta factory
 // creator class.
-template <class TestSuite>
+template <class TestSuite> 
 class TestMetaFactory
-    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
+    : public TestMetaFactoryBase<typename TestSuite::ParamType> { 
  public:
-  using ParamType = typename TestSuite::ParamType;
+  using ParamType = typename TestSuite::ParamType; 
 
   TestMetaFactory() {}
 
-  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
-    return new ParameterizedTestFactory<TestSuite>(parameter);
+  TestFactoryBase* CreateTestFactory(ParamType parameter) override { 
+    return new ParameterizedTestFactory<TestSuite>(parameter); 
   }
 
  private:
@@ -445,128 +445,128 @@ class TestMetaFactory
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
-// ParameterizedTestSuiteInfoBase is a generic interface
-// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
+// ParameterizedTestSuiteInfoBase is a generic interface 
+// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase 
 // accumulates test information provided by TEST_P macro invocations
-// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
+// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations 
 // and uses that information to register all resulting test instances
-// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
-// a collection of pointers to the ParameterizedTestSuiteInfo objects
+// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds 
+// a collection of pointers to the ParameterizedTestSuiteInfo objects 
 // and calls RegisterTests() on each of them when asked.
-class ParameterizedTestSuiteInfoBase {
+class ParameterizedTestSuiteInfoBase { 
  public:
-  virtual ~ParameterizedTestSuiteInfoBase() {}
+  virtual ~ParameterizedTestSuiteInfoBase() {} 
 
-  // Base part of test suite name for display purposes.
-  virtual const std::string& GetTestSuiteName() const = 0;
-  // Test suite id to verify identity.
-  virtual TypeId GetTestSuiteTypeId() const = 0;
+  // Base part of test suite name for display purposes. 
+  virtual const std::string& GetTestSuiteName() const = 0; 
+  // Test suite id to verify identity. 
+  virtual TypeId GetTestSuiteTypeId() const = 0; 
   // UnitTest class invokes this method to register tests in this
-  // test suite right before running them in RUN_ALL_TESTS macro.
-  // This method should not be called more than once on any single
-  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  // test suite right before running them in RUN_ALL_TESTS macro. 
+  // This method should not be called more than once on any single 
+  // instance of a ParameterizedTestSuiteInfoBase derived class. 
   virtual void RegisterTests() = 0;
 
  protected:
-  ParameterizedTestSuiteInfoBase() {}
+  ParameterizedTestSuiteInfoBase() {} 
 
  private:
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase); 
 };
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
-// Report a the name of a test_suit as safe to ignore
-// as the side effect of construction of this type.
-struct GTEST_API_ MarkAsIgnored {
-  explicit MarkAsIgnored(const char* test_suite);
-};
-
-GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
-                                        CodeLocation location, bool has_test_p);
-
-// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
-//
-// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
-// macro invocations for a particular test suite and generators
-// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
-// test suite. It registers tests with all values generated by all
+// Report a the name of a test_suit as safe to ignore 
+// as the side effect of construction of this type. 
+struct GTEST_API_ MarkAsIgnored { 
+  explicit MarkAsIgnored(const char* test_suite); 
+}; 
+ 
+GTEST_API_ void InsertSyntheticTestCase(const std::string& name, 
+                                        CodeLocation location, bool has_test_p); 
+ 
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 
+// 
+// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P 
+// macro invocations for a particular test suite and generators 
+// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that 
+// test suite. It registers tests with all values generated by all 
 // generators when asked.
-template <class TestSuite>
-class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
+template <class TestSuite> 
+class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase { 
  public:
   // ParamType and GeneratorCreationFunc are private types but are required
   // for declarations of public methods AddTestPattern() and
-  // AddTestSuiteInstantiation().
-  using ParamType = typename TestSuite::ParamType;
+  // AddTestSuiteInstantiation(). 
+  using ParamType = typename TestSuite::ParamType; 
   // A function that returns an instance of appropriate generator type.
   typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
-  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
-
-  explicit ParameterizedTestSuiteInfo(const char* name,
-                                      CodeLocation code_location)
-      : test_suite_name_(name), code_location_(code_location) {}
-
-  // Test suite base name for display purposes.
-  const std::string& GetTestSuiteName() const override {
-    return test_suite_name_;
-  }
-  // Test suite id to verify identity.
-  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
+  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&); 
+
+  explicit ParameterizedTestSuiteInfo(const char* name, 
+                                      CodeLocation code_location) 
+      : test_suite_name_(name), code_location_(code_location) {} 
+
+  // Test suite base name for display purposes. 
+  const std::string& GetTestSuiteName() const override { 
+    return test_suite_name_; 
+  } 
+  // Test suite id to verify identity. 
+  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); } 
   // TEST_P macro uses AddTestPattern() to record information
   // about a single test in a LocalTestInfo structure.
-  // test_suite_name is the base name of the test suite (without invocation
+  // test_suite_name is the base name of the test suite (without invocation 
   // prefix). test_base_name is the name of an individual test without
   // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
-  // test suite base name and DoBar is test base name.
-  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
-                      TestMetaFactoryBase<ParamType>* meta_factory,
-                      CodeLocation code_location) {
-    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
-        test_suite_name, test_base_name, meta_factory, code_location)));
+  // test suite base name and DoBar is test base name. 
+  void AddTestPattern(const char* test_suite_name, const char* test_base_name, 
+                      TestMetaFactoryBase<ParamType>* meta_factory, 
+                      CodeLocation code_location) { 
+    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo( 
+        test_suite_name, test_base_name, meta_factory, code_location))); 
   }
-  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
+  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information 
   // about a generator.
-  int AddTestSuiteInstantiation(const std::string& instantiation_name,
-                                GeneratorCreationFunc* func,
-                                ParamNameGeneratorFunc* name_func,
-                                const char* file, int line) {
+  int AddTestSuiteInstantiation(const std::string& instantiation_name, 
+                                GeneratorCreationFunc* func, 
+                                ParamNameGeneratorFunc* name_func, 
+                                const char* file, int line) { 
     instantiations_.push_back(
         InstantiationInfo(instantiation_name, func, name_func, file, line));
     return 0;  // Return value used only to run this method in namespace scope.
   }
-  // UnitTest class invokes this method to register tests in this test suite
-  // right before running tests in RUN_ALL_TESTS macro.
-  // This method should not be called more than once on any single
-  // instance of a ParameterizedTestSuiteInfoBase derived class.
-  // UnitTest has a guard to prevent from calling this method more than once.
-  void RegisterTests() override {
-    bool generated_instantiations = false;
-
+  // UnitTest class invokes this method to register tests in this test suite 
+  // right before running tests in RUN_ALL_TESTS macro. 
+  // This method should not be called more than once on any single 
+  // instance of a ParameterizedTestSuiteInfoBase derived class. 
+  // UnitTest has a guard to prevent from calling this method more than once. 
+  void RegisterTests() override { 
+    bool generated_instantiations = false; 
+ 
     for (typename TestInfoContainer::iterator test_it = tests_.begin();
          test_it != tests_.end(); ++test_it) {
-      std::shared_ptr<TestInfo> test_info = *test_it;
+      std::shared_ptr<TestInfo> test_info = *test_it; 
       for (typename InstantiationContainer::iterator gen_it =
                instantiations_.begin(); gen_it != instantiations_.end();
                ++gen_it) {
-        const std::string& instantiation_name = gen_it->name;
+        const std::string& instantiation_name = gen_it->name; 
         ParamGenerator<ParamType> generator((*gen_it->generator)());
         ParamNameGeneratorFunc* name_func = gen_it->name_func;
         const char* file = gen_it->file;
         int line = gen_it->line;
 
-        std::string test_suite_name;
+        std::string test_suite_name; 
         if ( !instantiation_name.empty() )
-          test_suite_name = instantiation_name + "/";
-        test_suite_name += test_info->test_suite_base_name;
+          test_suite_name = instantiation_name + "/"; 
+        test_suite_name += test_info->test_suite_base_name; 
 
         size_t i = 0;
         std::set<std::string> test_param_names;
         for (typename ParamGenerator<ParamType>::iterator param_it =
                  generator.begin();
              param_it != generator.end(); ++param_it, ++i) {
-          generated_instantiations = true;
-
+          generated_instantiations = true; 
+ 
           Message test_name_stream;
 
           std::string param_name = name_func(
@@ -583,48 +583,48 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
 
           test_param_names.insert(param_name);
 
-          if (!test_info->test_base_name.empty()) {
-            test_name_stream << test_info->test_base_name << "/";
-          }
-          test_name_stream << param_name;
+          if (!test_info->test_base_name.empty()) { 
+            test_name_stream << test_info->test_base_name << "/"; 
+          } 
+          test_name_stream << param_name; 
           MakeAndRegisterTestInfo(
-              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
-              nullptr,  // No type parameter.
-              PrintToString(*param_it).c_str(), test_info->code_location,
-              GetTestSuiteTypeId(),
-              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
-              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(), 
+              nullptr,  // No type parameter. 
+              PrintToString(*param_it).c_str(), test_info->code_location, 
+              GetTestSuiteTypeId(), 
+              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line), 
+              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line), 
               test_info->test_meta_factory->CreateTestFactory(*param_it));
         }  // for param_it
       }  // for gen_it
     }  // for test_it
-
-    if (!generated_instantiations) {
-      // There are no generaotrs, or they all generate nothing ...
-      InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
-                              !tests_.empty());
-    }
-  }    // RegisterTests
+ 
+    if (!generated_instantiations) { 
+      // There are no generaotrs, or they all generate nothing ... 
+      InsertSyntheticTestCase(GetTestSuiteName(), code_location_, 
+                              !tests_.empty()); 
+    } 
+  }    // RegisterTests 
 
  private:
   // LocalTestInfo structure keeps information about a single test registered
   // with TEST_P macro.
   struct TestInfo {
-    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
-             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
-             CodeLocation a_code_location)
-        : test_suite_base_name(a_test_suite_base_name),
-          test_base_name(a_test_base_name),
-          test_meta_factory(a_test_meta_factory),
-          code_location(a_code_location) {}
-
-    const std::string test_suite_base_name;
-    const std::string test_base_name;
-    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
-    const CodeLocation code_location;
+    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name, 
+             TestMetaFactoryBase<ParamType>* a_test_meta_factory, 
+             CodeLocation a_code_location) 
+        : test_suite_base_name(a_test_suite_base_name), 
+          test_base_name(a_test_base_name), 
+          test_meta_factory(a_test_meta_factory), 
+          code_location(a_code_location) {} 
+
+    const std::string test_suite_base_name; 
+    const std::string test_base_name; 
+    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; 
+    const CodeLocation code_location; 
   };
-  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
-  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
+  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >; 
+  // Records data received from INSTANTIATE_TEST_SUITE_P macros: 
   //  <Instantiation name, Sequence generator creation function,
   //     Name generator function, Source file, Source line>
   struct InstantiationInfo {
@@ -654,294 +654,294 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
 
     // Check for invalid characters
     for (std::string::size_type index = 0; index < name.size(); ++index) {
-      if (!IsAlNum(name[index]) && name[index] != '_')
+      if (!IsAlNum(name[index]) && name[index] != '_') 
         return false;
     }
 
     return true;
   }
 
-  const std::string test_suite_name_;
+  const std::string test_suite_name_; 
   CodeLocation code_location_;
   TestInfoContainer tests_;
   InstantiationContainer instantiations_;
 
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
-};  // class ParameterizedTestSuiteInfo
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-template <class TestCase>
-using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo); 
+};  // class ParameterizedTestSuiteInfo 
 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+template <class TestCase> 
+using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>; 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
-// ParameterizedTestSuiteRegistry contains a map of
-// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
-// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
-// ParameterizedTestSuiteInfo descriptors.
-class ParameterizedTestSuiteRegistry {
+// ParameterizedTestSuiteRegistry contains a map of 
+// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P 
+// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding 
+// ParameterizedTestSuiteInfo descriptors. 
+class ParameterizedTestSuiteRegistry { 
  public:
-  ParameterizedTestSuiteRegistry() {}
-  ~ParameterizedTestSuiteRegistry() {
-    for (auto& test_suite_info : test_suite_infos_) {
-      delete test_suite_info;
+  ParameterizedTestSuiteRegistry() {} 
+  ~ParameterizedTestSuiteRegistry() { 
+    for (auto& test_suite_info : test_suite_infos_) { 
+      delete test_suite_info; 
     }
   }
 
   // Looks up or creates and returns a structure containing information about
-  // tests and instantiations of a particular test suite.
-  template <class TestSuite>
-  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
-      const char* test_suite_name, CodeLocation code_location) {
-    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
-    for (auto& test_suite_info : test_suite_infos_) {
-      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
-        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
+  // tests and instantiations of a particular test suite. 
+  template <class TestSuite> 
+  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder( 
+      const char* test_suite_name, CodeLocation code_location) { 
+    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr; 
+    for (auto& test_suite_info : test_suite_infos_) { 
+      if (test_suite_info->GetTestSuiteName() == test_suite_name) { 
+        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) { 
           // Complain about incorrect usage of Google Test facilities
           // and terminate the program since we cannot guaranty correct
-          // test suite setup and tear-down in this case.
-          ReportInvalidTestSuiteType(test_suite_name, code_location);
+          // test suite setup and tear-down in this case. 
+          ReportInvalidTestSuiteType(test_suite_name, code_location); 
           posix::Abort();
         } else {
           // At this point we are sure that the object we found is of the same
           // type we are looking for, so we downcast it to that type
           // without further checks.
           typed_test_info = CheckedDowncastToActualType<
-              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
+              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info); 
         }
         break;
       }
     }
-    if (typed_test_info == nullptr) {
-      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
-          test_suite_name, code_location);
-      test_suite_infos_.push_back(typed_test_info);
+    if (typed_test_info == nullptr) { 
+      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>( 
+          test_suite_name, code_location); 
+      test_suite_infos_.push_back(typed_test_info); 
     }
     return typed_test_info;
   }
   void RegisterTests() {
-    for (auto& test_suite_info : test_suite_infos_) {
-      test_suite_info->RegisterTests();
+    for (auto& test_suite_info : test_suite_infos_) { 
+      test_suite_info->RegisterTests(); 
     }
   }
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  template <class TestCase>
-  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      const char* test_case_name, CodeLocation code_location) {
-    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
-  }
-
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
- private:
-  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
-
-  TestSuiteInfoContainer test_suite_infos_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
-};
-
-// Keep track of what type-parameterized test suite are defined and
-// where as well as which are intatiated. This allows susequently
-// identifying suits that are defined but never used.
-class TypeParameterizedTestSuiteRegistry {
- public:
-  // Add a suite definition
-  void RegisterTestSuite(const char* test_suite_name,
-                         CodeLocation code_location);
-
-  // Add an instantiation of a suit.
-  void RegisterInstantiation(const char* test_suite_name);
-
-  // For each suit repored as defined but not reported as instantiation,
-  // emit a test that reports that fact (configurably, as an error).
-  void CheckForInstantiations();
-
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  template <class TestCase> 
+  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( 
+      const char* test_case_name, CodeLocation code_location) { 
+    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location); 
+  } 
+
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
  private:
-  struct TypeParameterizedTestSuiteInfo {
-    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
-        : code_location(c), instantiated(false) {}
-
-    CodeLocation code_location;
-    bool instantiated;
-  };
-
-  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
-};
-
-}  // namespace internal
-
-// Forward declarations of ValuesIn(), which is implemented in
-// include/gtest/gtest-param-test.h.
-template <class Container>
-internal::ParamGenerator<typename Container::value_type> ValuesIn(
-    const Container& container);
-
-namespace internal {
-// Used in the Values() function to provide polymorphic capabilities.
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
+  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>; 
 
-template <typename... Ts>
-class ValueArray {
- public:
-  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
-
-  template <typename T>
-  operator ParamGenerator<T>() const {  // NOLINT
-    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
-  }
-
- private:
-  template <typename T, size_t... I>
-  std::vector<T> MakeVector(IndexSequence<I...>) const {
-    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
-  }
+  TestSuiteInfoContainer test_suite_infos_; 
 
-  FlatTuple<Ts...> v_;
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-template <typename... T>
-class CartesianProductGenerator
-    : public ParamGeneratorInterface<::std::tuple<T...>> {
- public:
-  typedef ::std::tuple<T...> ParamType;
-
-  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
-      : generators_(g) {}
-  ~CartesianProductGenerator() override {}
-
-  ParamIteratorInterface<ParamType>* Begin() const override {
-    return new Iterator(this, generators_, false);
-  }
-  ParamIteratorInterface<ParamType>* End() const override {
-    return new Iterator(this, generators_, true);
-  }
-
- private:
-  template <class I>
-  class IteratorImpl;
-  template <size_t... I>
-  class IteratorImpl<IndexSequence<I...>>
-      : public ParamIteratorInterface<ParamType> {
-   public:
-    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
-             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
-        : base_(base),
-          begin_(std::get<I>(generators).begin()...),
-          end_(std::get<I>(generators).end()...),
-          current_(is_end ? end_ : begin_) {
-      ComputeCurrentValue();
-    }
-    ~IteratorImpl() override {}
-
-    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
-      return base_;
-    }
-    // Advance should not be called on beyond-of-range iterators
-    // so no component iterators must be beyond end of range, either.
-    void Advance() override {
-      assert(!AtEnd());
-      // Advance the last iterator.
-      ++std::get<sizeof...(T) - 1>(current_);
-      // if that reaches end, propagate that up.
-      AdvanceIfEnd<sizeof...(T) - 1>();
-      ComputeCurrentValue();
-    }
-    ParamIteratorInterface<ParamType>* Clone() const override {
-      return new IteratorImpl(*this);
-    }
-
-    const ParamType* Current() const override { return current_value_.get(); }
-
-    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
-      // Having the same base generator guarantees that the other
-      // iterator is of the same type and we can downcast.
-      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
-          << "The program attempted to compare iterators "
-          << "from different generators." << std::endl;
-      const IteratorImpl* typed_other =
-          CheckedDowncastToActualType<const IteratorImpl>(&other);
-
-      // We must report iterators equal if they both point beyond their
-      // respective ranges. That can happen in a variety of fashions,
-      // so we have to consult AtEnd().
-      if (AtEnd() && typed_other->AtEnd()) return true;
-
-      bool same = true;
-      bool dummy[] = {
-          (same = same && std::get<I>(current_) ==
-                              std::get<I>(typed_other->current_))...};
-      (void)dummy;
-      return same;
-    }
-
-   private:
-    template <size_t ThisI>
-    void AdvanceIfEnd() {
-      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
-
-      bool last = ThisI == 0;
-      if (last) {
-        // We are done. Nothing else to propagate.
-        return;
-      }
-
-      constexpr size_t NextI = ThisI - (ThisI != 0);
-      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
-      ++std::get<NextI>(current_);
-      AdvanceIfEnd<NextI>();
-    }
-
-    void ComputeCurrentValue() {
-      if (!AtEnd())
-        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
-    }
-    bool AtEnd() const {
-      bool at_end = false;
-      bool dummy[] = {
-          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
-      (void)dummy;
-      return at_end;
-    }
-
-    const ParamGeneratorInterface<ParamType>* const base_;
-    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
-    std::tuple<typename ParamGenerator<T>::iterator...> end_;
-    std::tuple<typename ParamGenerator<T>::iterator...> current_;
-    std::shared_ptr<ParamType> current_value_;
-  };
-
-  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
-
-  std::tuple<ParamGenerator<T>...> generators_;
-};
-
-template <class... Gen>
-class CartesianProductHolder {
- public:
-  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
-  template <typename... T>
-  operator ParamGenerator<::std::tuple<T...>>() const {
-    return ParamGenerator<::std::tuple<T...>>(
-        new CartesianProductGenerator<T...>(generators_));
-  }
-
- private:
-  std::tuple<Gen...> generators_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry); 
 };
 
+// Keep track of what type-parameterized test suite are defined and 
+// where as well as which are intatiated. This allows susequently 
+// identifying suits that are defined but never used. 
+class TypeParameterizedTestSuiteRegistry { 
+ public: 
+  // Add a suite definition 
+  void RegisterTestSuite(const char* test_suite_name, 
+                         CodeLocation code_location); 
+ 
+  // Add an instantiation of a suit. 
+  void RegisterInstantiation(const char* test_suite_name); 
+ 
+  // For each suit repored as defined but not reported as instantiation, 
+  // emit a test that reports that fact (configurably, as an error). 
+  void CheckForInstantiations(); 
+ 
+ private: 
+  struct TypeParameterizedTestSuiteInfo { 
+    explicit TypeParameterizedTestSuiteInfo(CodeLocation c) 
+        : code_location(c), instantiated(false) {} 
+ 
+    CodeLocation code_location; 
+    bool instantiated; 
+  }; 
+ 
+  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_; 
+}; 
+ 
 }  // namespace internal
+ 
+// Forward declarations of ValuesIn(), which is implemented in 
+// include/gtest/gtest-param-test.h. 
+template <class Container> 
+internal::ParamGenerator<typename Container::value_type> ValuesIn( 
+    const Container& container); 
+ 
+namespace internal { 
+// Used in the Values() function to provide polymorphic capabilities. 
+ 
+#ifdef _MSC_VER 
+#pragma warning(push) 
+#pragma warning(disable : 4100) 
+#endif 
+ 
+template <typename... Ts> 
+class ValueArray { 
+ public: 
+  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {} 
+ 
+  template <typename T> 
+  operator ParamGenerator<T>() const {  // NOLINT 
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>())); 
+  } 
+ 
+ private: 
+  template <typename T, size_t... I> 
+  std::vector<T> MakeVector(IndexSequence<I...>) const { 
+    return std::vector<T>{static_cast<T>(v_.template Get<I>())...}; 
+  } 
+ 
+  FlatTuple<Ts...> v_; 
+}; 
+ 
+#ifdef _MSC_VER 
+#pragma warning(pop) 
+#endif 
+ 
+template <typename... T> 
+class CartesianProductGenerator 
+    : public ParamGeneratorInterface<::std::tuple<T...>> { 
+ public: 
+  typedef ::std::tuple<T...> ParamType; 
+ 
+  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g) 
+      : generators_(g) {} 
+  ~CartesianProductGenerator() override {} 
+ 
+  ParamIteratorInterface<ParamType>* Begin() const override { 
+    return new Iterator(this, generators_, false); 
+  } 
+  ParamIteratorInterface<ParamType>* End() const override { 
+    return new Iterator(this, generators_, true); 
+  } 
+ 
+ private: 
+  template <class I> 
+  class IteratorImpl; 
+  template <size_t... I> 
+  class IteratorImpl<IndexSequence<I...>> 
+      : public ParamIteratorInterface<ParamType> { 
+   public: 
+    IteratorImpl(const ParamGeneratorInterface<ParamType>* base, 
+             const std::tuple<ParamGenerator<T>...>& generators, bool is_end) 
+        : base_(base), 
+          begin_(std::get<I>(generators).begin()...), 
+          end_(std::get<I>(generators).end()...), 
+          current_(is_end ? end_ : begin_) { 
+      ComputeCurrentValue(); 
+    } 
+    ~IteratorImpl() override {} 
+ 
+    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override { 
+      return base_; 
+    } 
+    // Advance should not be called on beyond-of-range iterators 
+    // so no component iterators must be beyond end of range, either. 
+    void Advance() override { 
+      assert(!AtEnd()); 
+      // Advance the last iterator. 
+      ++std::get<sizeof...(T) - 1>(current_); 
+      // if that reaches end, propagate that up. 
+      AdvanceIfEnd<sizeof...(T) - 1>(); 
+      ComputeCurrentValue(); 
+    } 
+    ParamIteratorInterface<ParamType>* Clone() const override { 
+      return new IteratorImpl(*this); 
+    } 
+ 
+    const ParamType* Current() const override { return current_value_.get(); } 
+ 
+    bool Equals(const ParamIteratorInterface<ParamType>& other) const override { 
+      // Having the same base generator guarantees that the other 
+      // iterator is of the same type and we can downcast. 
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) 
+          << "The program attempted to compare iterators " 
+          << "from different generators." << std::endl; 
+      const IteratorImpl* typed_other = 
+          CheckedDowncastToActualType<const IteratorImpl>(&other); 
+ 
+      // We must report iterators equal if they both point beyond their 
+      // respective ranges. That can happen in a variety of fashions, 
+      // so we have to consult AtEnd(). 
+      if (AtEnd() && typed_other->AtEnd()) return true; 
+ 
+      bool same = true; 
+      bool dummy[] = { 
+          (same = same && std::get<I>(current_) == 
+                              std::get<I>(typed_other->current_))...}; 
+      (void)dummy; 
+      return same; 
+    } 
+ 
+   private: 
+    template <size_t ThisI> 
+    void AdvanceIfEnd() { 
+      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return; 
+ 
+      bool last = ThisI == 0; 
+      if (last) { 
+        // We are done. Nothing else to propagate. 
+        return; 
+      } 
+ 
+      constexpr size_t NextI = ThisI - (ThisI != 0); 
+      std::get<ThisI>(current_) = std::get<ThisI>(begin_); 
+      ++std::get<NextI>(current_); 
+      AdvanceIfEnd<NextI>(); 
+    } 
+ 
+    void ComputeCurrentValue() { 
+      if (!AtEnd()) 
+        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...); 
+    } 
+    bool AtEnd() const { 
+      bool at_end = false; 
+      bool dummy[] = { 
+          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...}; 
+      (void)dummy; 
+      return at_end; 
+    } 
+ 
+    const ParamGeneratorInterface<ParamType>* const base_; 
+    std::tuple<typename ParamGenerator<T>::iterator...> begin_; 
+    std::tuple<typename ParamGenerator<T>::iterator...> end_; 
+    std::tuple<typename ParamGenerator<T>::iterator...> current_; 
+    std::shared_ptr<ParamType> current_value_; 
+  }; 
+ 
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>; 
+ 
+  std::tuple<ParamGenerator<T>...> generators_; 
+}; 
+ 
+template <class... Gen> 
+class CartesianProductHolder { 
+ public: 
+  CartesianProductHolder(const Gen&... g) : generators_(g...) {} 
+  template <typename... T> 
+  operator ParamGenerator<::std::tuple<T...>>() const { 
+    return ParamGenerator<::std::tuple<T...>>( 
+        new CartesianProductGenerator<T...>(generators_)); 
+  } 
+ 
+ private: 
+  std::tuple<Gen...> generators_; 
+}; 
+ 
+}  // namespace internal 
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port-arch.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port-arch.h
index dd845915e3..0fec50378a 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@@ -27,20 +27,20 @@
 // (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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file defines the GTEST_OS_* macro.
 // It is separate from gtest-port.h so that custom/gtest-port.h can include it.
 
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ 
 
 // Determines the platform on which Google Test is compiled.
 #ifdef __CYGWIN__
 # define GTEST_OS_CYGWIN 1
-# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
-#  define GTEST_OS_WINDOWS_MINGW 1
-#  define GTEST_OS_WINDOWS 1
+# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__) 
+#  define GTEST_OS_WINDOWS_MINGW 1 
+#  define GTEST_OS_WINDOWS 1 
 #elif defined _WIN32
 # define GTEST_OS_WINDOWS 1
 # ifdef _WIN32_WCE
@@ -53,9 +53,9 @@
 #   define GTEST_OS_WINDOWS_PHONE 1
 #  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
 #   define GTEST_OS_WINDOWS_RT 1
-#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
-#   define GTEST_OS_WINDOWS_PHONE 1
-#   define GTEST_OS_WINDOWS_TV_TITLE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE) 
+#   define GTEST_OS_WINDOWS_PHONE 1 
+#   define GTEST_OS_WINDOWS_TV_TITLE 1 
 #  else
     // WINAPI_FAMILY defined but no known partition matched.
     // Default to desktop.
@@ -64,22 +64,22 @@
 # else
 #  define GTEST_OS_WINDOWS_DESKTOP 1
 # endif  // _WIN32_WCE
-#elif defined __OS2__
-# define GTEST_OS_OS2 1
+#elif defined __OS2__ 
+# define GTEST_OS_OS2 1 
 #elif defined __APPLE__
 # define GTEST_OS_MAC 1
-# include <TargetConditionals.h>
+# include <TargetConditionals.h> 
 # if TARGET_OS_IPHONE
 #  define GTEST_OS_IOS 1
 # endif
-#elif defined __DragonFly__
-# define GTEST_OS_DRAGONFLY 1
+#elif defined __DragonFly__ 
+# define GTEST_OS_DRAGONFLY 1 
 #elif defined __FreeBSD__
 # define GTEST_OS_FREEBSD 1
-#elif defined __Fuchsia__
-# define GTEST_OS_FUCHSIA 1
-#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
-# define GTEST_OS_GNU_KFREEBSD 1
+#elif defined __Fuchsia__ 
+# define GTEST_OS_FUCHSIA 1 
+#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__) 
+# define GTEST_OS_GNU_KFREEBSD 1 
 #elif defined __linux__
 # define GTEST_OS_LINUX 1
 # if defined __ANDROID__
@@ -95,20 +95,20 @@
 # define GTEST_OS_HPUX 1
 #elif defined __native_client__
 # define GTEST_OS_NACL 1
-#elif defined __NetBSD__
-# define GTEST_OS_NETBSD 1
+#elif defined __NetBSD__ 
+# define GTEST_OS_NETBSD 1 
 #elif defined __OpenBSD__
 # define GTEST_OS_OPENBSD 1
 #elif defined __QNX__
 # define GTEST_OS_QNX 1
-#elif defined(__HAIKU__)
-#define GTEST_OS_HAIKU 1
-#elif defined ESP8266
-#define GTEST_OS_ESP8266 1
-#elif defined ESP32
-#define GTEST_OS_ESP32 1
-#elif defined(__XTENSA__)
-#define GTEST_OS_XTENSA 1
+#elif defined(__HAIKU__) 
+#define GTEST_OS_HAIKU 1 
+#elif defined ESP8266 
+#define GTEST_OS_ESP8266 1 
+#elif defined ESP32 
+#define GTEST_OS_ESP32 1 
+#elif defined(__XTENSA__) 
+#define GTEST_OS_XTENSA 1 
 #endif  // __CYGWIN__
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port.h
index 5b5d8ad35d..c933140f6b 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-port.h
@@ -38,10 +38,10 @@
 // files are expected to #include this.  Therefore, it cannot #include
 // any other Google Test header.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 
 
 // Environment-describing macros
 // -----------------------------
@@ -95,12 +95,12 @@
 //   GTEST_CREATE_SHARED_LIBRARY
 //                            - Define to 1 when compiling Google Test itself
 //                              as a shared library.
-//   GTEST_DEFAULT_DEATH_TEST_STYLE
-//                            - The default value of --gtest_death_test_style.
-//                              The legacy default has been "fast" in the open
-//                              source version since 2008. The recommended value
-//                              is "threadsafe", and can be set in
-//                              custom/gtest-port.h.
+//   GTEST_DEFAULT_DEATH_TEST_STYLE 
+//                            - The default value of --gtest_death_test_style. 
+//                              The legacy default has been "fast" in the open 
+//                              source version since 2008. The recommended value 
+//                              is "threadsafe", and can be set in 
+//                              custom/gtest-port.h. 
 
 // Platform-indicating macros
 // --------------------------
@@ -113,20 +113,20 @@
 //
 //   GTEST_OS_AIX      - IBM AIX
 //   GTEST_OS_CYGWIN   - Cygwin
-//   GTEST_OS_DRAGONFLY - DragonFlyBSD
+//   GTEST_OS_DRAGONFLY - DragonFlyBSD 
 //   GTEST_OS_FREEBSD  - FreeBSD
-//   GTEST_OS_FUCHSIA  - Fuchsia
-//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
-//   GTEST_OS_HAIKU    - Haiku
+//   GTEST_OS_FUCHSIA  - Fuchsia 
+//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD 
+//   GTEST_OS_HAIKU    - Haiku 
 //   GTEST_OS_HPUX     - HP-UX
 //   GTEST_OS_LINUX    - Linux
 //     GTEST_OS_LINUX_ANDROID - Google Android
 //   GTEST_OS_MAC      - Mac OS X
 //     GTEST_OS_IOS    - iOS
 //   GTEST_OS_NACL     - Google Native Client (NaCl)
-//   GTEST_OS_NETBSD   - NetBSD
+//   GTEST_OS_NETBSD   - NetBSD 
 //   GTEST_OS_OPENBSD  - OpenBSD
-//   GTEST_OS_OS2      - OS/2
+//   GTEST_OS_OS2      - OS/2 
 //   GTEST_OS_QNX      - QNX
 //   GTEST_OS_SOLARIS  - Sun Solaris
 //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
@@ -137,7 +137,7 @@
 //     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
 //   GTEST_OS_ZOS      - z/OS
 //
-// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
+// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the 
 // most stable support.  Since core members of the Google Test project
 // don't have access to other platforms, support for them may be less
 // stable.  If you notice any problems on your platform, please notify
@@ -167,12 +167,12 @@
 //   GTEST_HAS_TYPED_TEST   - typed tests
 //   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
 //   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
-//   GOOGLETEST_CM0007 DO NOT DELETE
+//   GOOGLETEST_CM0007 DO NOT DELETE 
 //   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
 //                            GTEST_HAS_POSIX_RE (see above) which users can
 //                            define themselves.
 //   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
-//                            the above RE\b(s) are mutually exclusive.
+//                            the above RE\b(s) are mutually exclusive. 
 
 // Misc public macros
 // ------------------
@@ -190,27 +190,27 @@
 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
 //   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
 //                              variable don't have to be used.
-//   GTEST_DISALLOW_ASSIGN_   - disables copy operator=.
+//   GTEST_DISALLOW_ASSIGN_   - disables copy operator=. 
 //   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
-//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=.
-//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
+//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=. 
+//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=. 
 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
 //   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
 //                                        suppressed (constant conditional).
 //   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
 //                                        is suppressed.
-//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
-//                            UniversalPrinter<absl::any> specializations.
-//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
-//   or
-//                                 UniversalPrinter<absl::optional>
-//                                 specializations.
-//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
-//                                    Matcher<absl::string_view>
-//                                    specializations.
-//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
-//                                UniversalPrinter<absl::variant>
-//                                specializations.
+//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or 
+//                            UniversalPrinter<absl::any> specializations. 
+//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional> 
+//   or 
+//                                 UniversalPrinter<absl::optional> 
+//                                 specializations. 
+//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or 
+//                                    Matcher<absl::string_view> 
+//                                    specializations. 
+//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or 
+//                                UniversalPrinter<absl::variant> 
+//                                specializations. 
 //
 // Synchronization:
 //   Mutex, MutexLock, ThreadLocal, GetThreadCount()
@@ -218,10 +218,10 @@
 //
 // Regular expressions:
 //   RE             - a simple regular expression class using the POSIX
-//                    Extended Regular Expression syntax on UNIX-like platforms
-//                    GOOGLETEST_CM0008 DO NOT DELETE
-//                    or a reduced regular exception syntax on other
-//                    platforms, including Windows.
+//                    Extended Regular Expression syntax on UNIX-like platforms 
+//                    GOOGLETEST_CM0008 DO NOT DELETE 
+//                    or a reduced regular exception syntax on other 
+//                    platforms, including Windows. 
 // Logging:
 //   GTEST_LOG_()   - logs messages at the specified severity level.
 //   LogToStderr()  - directs all log messages to stderr.
@@ -237,7 +237,7 @@
 //
 // Integer types:
 //   TypeWithSize   - maps an integer to a int type.
-//   TimeInMillis   - integers of known sizes.
+//   TimeInMillis   - integers of known sizes. 
 //   BiggestInt     - the biggest signed integer type.
 //
 // Command-line utilities:
@@ -248,25 +248,25 @@
 // Environment variable utilities:
 //   GetEnv()             - gets the value of an environment variable.
 //   BoolFromGTestEnv()   - parses a bool environment variable.
-//   Int32FromGTestEnv()  - parses an int32_t environment variable.
+//   Int32FromGTestEnv()  - parses an int32_t environment variable. 
 //   StringFromGTestEnv() - parses a string environment variable.
-//
-// Deprecation warnings:
-//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
-//                                        deprecated; calling a marked function
-//                                        should generate a compiler warning
+// 
+// Deprecation warnings: 
+//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as 
+//                                        deprecated; calling a marked function 
+//                                        should generate a compiler warning 
 
 #include <ctype.h>   // for isspace, etc
 #include <stddef.h>  // for ptrdiff_t
-#include <stdio.h>
+#include <stdio.h> 
 #include <stdlib.h>
 #include <string.h>
-
-#include <cerrno>
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
+ 
+#include <cerrno> 
+#include <cstdint> 
+#include <limits> 
+#include <type_traits> 
+ 
 #ifndef _WIN32_WCE
 # include <sys/types.h>
 # include <sys/stat.h>
@@ -277,14 +277,14 @@
 # include <TargetConditionals.h>
 #endif
 
-#include <iostream>  // NOLINT
-#include <locale>
-#include <memory>
-#include <string>  // NOLINT
-#include <tuple>
+#include <iostream>  // NOLINT 
+#include <locale> 
+#include <memory> 
+#include <string>  // NOLINT 
+#include <tuple> 
 #include <vector>  // NOLINT
 
-#include "gtest/internal/custom/gtest-port.h"
+#include "gtest/internal/custom/gtest-port.h" 
 #include "gtest/internal/gtest-port-arch.h"
 
 #if !defined(GTEST_DEV_EMAIL_)
@@ -312,32 +312,32 @@
 //   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
 //   /* code that triggers warnings C4800 and C4385 */
 //   GTEST_DISABLE_MSC_WARNINGS_POP_()
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) 
 # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
     __pragma(warning(push))                        \
     __pragma(warning(disable: warnings))
 # define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
     __pragma(warning(pop))
 #else
-// Not all compilers are MSVC
+// Not all compilers are MSVC 
 # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
 # define GTEST_DISABLE_MSC_WARNINGS_POP_()
 #endif
 
-// Clang on Windows does not understand MSVC's pragma warning.
-// We need clang-specific way to disable function deprecation warning.
-#ifdef __clang__
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
-    _Pragma("clang diagnostic push")                                  \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
-    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
-#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    _Pragma("clang diagnostic pop")
-#else
-# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
-    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
-# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
-    GTEST_DISABLE_MSC_WARNINGS_POP_()
+// Clang on Windows does not understand MSVC's pragma warning. 
+// We need clang-specific way to disable function deprecation warning. 
+#ifdef __clang__ 
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \ 
+    _Pragma("clang diagnostic push")                                  \ 
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \ 
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"") 
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ 
+    _Pragma("clang diagnostic pop") 
+#else 
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ 
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996) 
+# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ 
+    GTEST_DISABLE_MSC_WARNINGS_POP_() 
 #endif
 
 // Brings in definitions for functions used in the testing::internal::posix
@@ -349,20 +349,20 @@
 #  include <io.h>
 # endif
 // In order to avoid having to include <windows.h>, use forward declaration
-#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
-// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
-// separate (equivalent) structs, instead of using typedef
-typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
-#else
-// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
+#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR) 
+// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two 
+// separate (equivalent) structs, instead of using typedef 
+typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION; 
+#else 
+// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION. 
 // This assumption is verified by
 // WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
-typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
-#endif
-#elif GTEST_OS_XTENSA
-#include <unistd.h>
-// Xtensa toolchains define strcasecmp in the string.h header instead of
-// strings.h. string.h is already included.
+typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION; 
+#endif 
+#elif GTEST_OS_XTENSA 
+#include <unistd.h> 
+// Xtensa toolchains define strcasecmp in the string.h header instead of 
+// strings.h. string.h is already included. 
 #else
 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
 // is not the case, we need to include headers that provide the functions
@@ -376,14 +376,14 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #  include <android/api-level.h>  // NOLINT
 #endif
 
-// Defines this to true if and only if Google Test can use POSIX regular
-// expressions.
+// Defines this to true if and only if Google Test can use POSIX regular 
+// expressions. 
 #ifndef GTEST_HAS_POSIX_RE
 # if GTEST_OS_LINUX_ANDROID
 // On Android, <regex.h> is only available starting with Gingerbread.
 #  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
 # else
-#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
+#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA) 
 # endif
 #endif
 
@@ -396,7 +396,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // won't compile otherwise.  We can #include it here as we already
 // included <stdlib.h>, which is guaranteed to define size_t through
 // <stddef.h>.
-# error #include <regex.h>  // NOLINT
+# error #include <regex.h>  // NOLINT 
 
 # define GTEST_USES_POSIX_RE 1
 
@@ -417,11 +417,11 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_HAS_EXCEPTIONS
 // The user didn't tell us whether exceptions are enabled, so we need
 // to figure it out.
-# if defined(_MSC_VER) && defined(_CPPUNWIND)
-// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
-#  define GTEST_HAS_EXCEPTIONS 1
-# elif defined(__BORLANDC__)
-// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
+# if defined(_MSC_VER) && defined(_CPPUNWIND) 
+// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled. 
+#  define GTEST_HAS_EXCEPTIONS 1 
+# elif defined(__BORLANDC__) 
+// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS 
 // macro to enable exceptions, so we'll do the same.
 // Assumes that exceptions are enabled by default.
 #  ifndef _HAS_EXCEPTIONS
@@ -429,17 +429,17 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #  endif  // _HAS_EXCEPTIONS
 #  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
 # elif defined(__clang__)
-// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
-// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
-// there can be cleanups for ObjC exceptions which also need cleanups, even if
-// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which
-// checks for C++ exceptions starting at clang r206352, but which checked for
-// cleanups prior to that. To reliably check for C++ exception availability with
-// clang, check for
+// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang 
+// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files, 
+// there can be cleanups for ObjC exceptions which also need cleanups, even if 
+// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which 
+// checks for C++ exceptions starting at clang r206352, but which checked for 
+// cleanups prior to that. To reliably check for C++ exception availability with 
+// clang, check for 
 // __EXCEPTIONS && __has_feature(cxx_exceptions).
 #  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
 # elif defined(__GNUC__) && __EXCEPTIONS
-// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled. 
 #  define GTEST_HAS_EXCEPTIONS 1
 # elif defined(__SUNPRO_CC)
 // Sun Pro CC supports exceptions.  However, there is no compile-time way of
@@ -447,7 +447,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // they are enabled unless the user tells us otherwise.
 #  define GTEST_HAS_EXCEPTIONS 1
 # elif defined(__IBMCPP__) && __EXCEPTIONS
-// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled. 
 #  define GTEST_HAS_EXCEPTIONS 1
 # elif defined(__HP_aCC)
 // Exception handling is in effect by default in HP aCC compiler. It has to
@@ -466,9 +466,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Cygwin 1.7 and below doesn't support ::std::wstring.
 // Solaris' libc++ doesn't support it either.  Android has
 // no support for it at least as recent as Froyo (2.2).
-#define GTEST_HAS_STD_WSTRING                                         \
-  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
-     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
+#define GTEST_HAS_STD_WSTRING                                         \ 
+  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 
+     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA)) 
 
 #endif  // GTEST_HAS_STD_WSTRING
 
@@ -479,15 +479,15 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 # ifdef _MSC_VER
 
-#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
+#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled. 
 #   define GTEST_HAS_RTTI 1
 #  else
 #   define GTEST_HAS_RTTI 0
 #  endif
 
-// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
-// enabled.
-# elif defined(__GNUC__)
+// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is 
+// enabled. 
+# elif defined(__GNUC__) 
 
 #  ifdef __GXX_RTTI
 // When building against STLport with the Android NDK and with
@@ -543,11 +543,11 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 //
 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
 // to your compiler flags.
-#define GTEST_HAS_PTHREAD                                                      \
-  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
-   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
-   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
-   GTEST_OS_HAIKU)
+#define GTEST_HAS_PTHREAD                                                      \ 
+  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \ 
+   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ 
+   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \ 
+   GTEST_OS_HAIKU) 
 #endif  // GTEST_HAS_PTHREAD
 
 #if GTEST_HAS_PTHREAD
@@ -568,12 +568,12 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 # if GTEST_OS_LINUX && !defined(__ia64__)
 #  if GTEST_OS_LINUX_ANDROID
-// On Android, clone() became available at different API levels for each 32-bit
-// architecture.
-#    if defined(__LP64__) || \
-        (defined(__arm__) && __ANDROID_API__ >= 9) || \
-        (defined(__mips__) && __ANDROID_API__ >= 12) || \
-        (defined(__i386__) && __ANDROID_API__ >= 17)
+// On Android, clone() became available at different API levels for each 32-bit 
+// architecture. 
+#    if defined(__LP64__) || \ 
+        (defined(__arm__) && __ANDROID_API__ >= 9) || \ 
+        (defined(__mips__) && __ANDROID_API__ >= 12) || \ 
+        (defined(__i386__) && __ANDROID_API__ >= 17) 
 #     define GTEST_HAS_CLONE 1
 #    else
 #     define GTEST_HAS_CLONE 0
@@ -592,22 +592,22 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_HAS_STREAM_REDIRECTION
 // By default, we assume that stream redirection is supported on all
 // platforms except known mobile ones.
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
-    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ 
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA 
 #  define GTEST_HAS_STREAM_REDIRECTION 0
 # else
 #  define GTEST_HAS_STREAM_REDIRECTION 1
-# endif  // !GTEST_OS_WINDOWS_MOBILE
+# endif  // !GTEST_OS_WINDOWS_MOBILE 
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
 // Determines whether to support death tests.
 // pops up a dialog window that cannot be suppressed programmatically.
-#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
-     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
-     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
-     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
-     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
-     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \ 
+     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \ 
+     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \ 
+     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \ 
+     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \ 
+     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU) 
 # define GTEST_HAS_DEATH_TEST 1
 #endif
 
@@ -615,7 +615,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
 // Sun Pro CC, IBM Visual Age, and HP aCC support.
-#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \ 
     defined(__IBMCPP__) || defined(__HP_aCC)
 # define GTEST_HAS_TYPED_TEST 1
 # define GTEST_HAS_TYPED_TEST_P 1
@@ -623,11 +623,11 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
 #define GTEST_WIDE_STRING_USES_UTF16_ \
-  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
+  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2) 
 
 // Determines whether test results can be streamed to a socket.
-#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
-    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \ 
+    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD 
 # define GTEST_CAN_STREAM_RESULTS_ 1
 #endif
 
@@ -669,56 +669,56 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 # define GTEST_ATTRIBUTE_UNUSED_
 #endif
 
-// Use this annotation before a function that takes a printf format string.
-#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
-# if defined(__MINGW_PRINTF_FORMAT)
-// MinGW has two different printf implementations. Ensure the format macro
-// matches the selected implementation. See
-// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
-                                 first_to_check)))
-# else
-#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
-       __attribute__((__format__(__printf__, string_index, first_to_check)))
-# endif
-#else
-# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
-#endif
-
-
-// A macro to disallow copy operator=
+// Use this annotation before a function that takes a printf format string. 
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC) 
+# if defined(__MINGW_PRINTF_FORMAT) 
+// MinGW has two different printf implementations. Ensure the format macro 
+// matches the selected implementation. See 
+// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/. 
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ 
+       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \ 
+                                 first_to_check))) 
+# else 
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ 
+       __attribute__((__format__(__printf__, string_index, first_to_check))) 
+# endif 
+#else 
+# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) 
+#endif 
+ 
+ 
+// A macro to disallow copy operator= 
 // This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_ASSIGN_(type) \
-  type& operator=(type const &) = delete
+#define GTEST_DISALLOW_ASSIGN_(type) \ 
+  type& operator=(type const &) = delete 
 
 // A macro to disallow copy constructor and operator=
 // This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
-  type(type const&) = delete;                 \
-  type& operator=(type const&) = delete
-
-// A macro to disallow move operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
-  type& operator=(type &&) noexcept = delete
-
-// A macro to disallow move constructor and operator=
-// This should be used in the private: declarations for a class.
-#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
-  type(type&&) noexcept = delete;             \
-  type& operator=(type&&) noexcept = delete
-
+#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \ 
+  type(type const&) = delete;                 \ 
+  type& operator=(type const&) = delete 
+
+// A macro to disallow move operator= 
+// This should be used in the private: declarations for a class. 
+#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \ 
+  type& operator=(type &&) noexcept = delete 
+ 
+// A macro to disallow move constructor and operator= 
+// This should be used in the private: declarations for a class. 
+#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \ 
+  type(type&&) noexcept = delete;             \ 
+  type& operator=(type&&) noexcept = delete 
+ 
 // Tell the compiler to warn about unused return values for functions declared
 // with this macro.  The macro should be used on function declarations
 // following the argument list:
 //
 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
-#if defined(__GNUC__) && !defined(COMPILER_ICC)
+#if defined(__GNUC__) && !defined(COMPILER_ICC) 
 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
 #else
 # define GTEST_MUST_USE_RESULT_
-#endif  // __GNUC__ && !COMPILER_ICC
+#endif  // __GNUC__ && !COMPILER_ICC 
 
 // MS C++ compiler emits warning when a conditional expression is compile time
 // constant. In some contexts this warning is false positive and needs to be
@@ -749,20 +749,20 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 
 #endif  // GTEST_HAS_SEH
 
-#ifndef GTEST_IS_THREADSAFE
-
-#define GTEST_IS_THREADSAFE                                                 \
-  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
-   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
-   GTEST_HAS_PTHREAD)
-
-#endif  // GTEST_IS_THREADSAFE
-
-// GTEST_API_ qualifies all symbols that must be exported. The definitions below
-// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
-// gtest/internal/custom/gtest-port.h
-#ifndef GTEST_API_
-
+#ifndef GTEST_IS_THREADSAFE 
+ 
+#define GTEST_IS_THREADSAFE                                                 \ 
+  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \ 
+   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \ 
+   GTEST_HAS_PTHREAD) 
+ 
+#endif  // GTEST_IS_THREADSAFE 
+ 
+// GTEST_API_ qualifies all symbols that must be exported. The definitions below 
+// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in 
+// gtest/internal/custom/gtest-port.h 
+#ifndef GTEST_API_ 
+ 
 #ifdef _MSC_VER
 # if GTEST_LINKED_AS_SHARED_LIBRARY
 #  define GTEST_API_ __declspec(dllimport)
@@ -771,18 +771,18 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 # endif
 #elif __GNUC__ >= 4 || defined(__clang__)
 # define GTEST_API_ __attribute__((visibility ("default")))
-#endif  // _MSC_VER
-
-#endif  // GTEST_API_
+#endif  // _MSC_VER 
 
+#endif  // GTEST_API_ 
+ 
 #ifndef GTEST_API_
 # define GTEST_API_
-#endif  // GTEST_API_
-
-#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
-# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
-#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
+#endif  // GTEST_API_ 
 
+#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE 
+# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast" 
+#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE 
+ 
 #ifdef __GNUC__
 // Ask the compiler to never inline a given function.
 # define GTEST_NO_INLINE_ __attribute__((noinline))
@@ -791,12 +791,12 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #endif
 
 // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
-#if !defined(GTEST_HAS_CXXABI_H_)
-# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
-#  define GTEST_HAS_CXXABI_H_ 1
-# else
-#  define GTEST_HAS_CXXABI_H_ 0
-# endif
+#if !defined(GTEST_HAS_CXXABI_H_) 
+# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) 
+#  define GTEST_HAS_CXXABI_H_ 1 
+# else 
+#  define GTEST_HAS_CXXABI_H_ 0 
+# endif 
 #endif
 
 // A function level attribute to disable checking for use of uninitialized
@@ -824,18 +824,18 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
 #endif  // __clang__
 
-// A function level attribute to disable HWAddressSanitizer instrumentation.
-#if defined(__clang__)
-# if __has_feature(hwaddress_sanitizer)
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
-       __attribute__((no_sanitize("hwaddress")))
-# else
-#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-# endif  // __has_feature(hwaddress_sanitizer)
-#else
-# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-#endif  // __clang__
-
+// A function level attribute to disable HWAddressSanitizer instrumentation. 
+#if defined(__clang__) 
+# if __has_feature(hwaddress_sanitizer) 
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \ 
+       __attribute__((no_sanitize("hwaddress"))) 
+# else 
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
+# endif  // __has_feature(hwaddress_sanitizer) 
+#else 
+# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
+#endif  // __clang__ 
+ 
 // A function level attribute to disable ThreadSanitizer instrumentation.
 #if defined(__clang__)
 # if __has_feature(thread_sanitizer)
@@ -852,13 +852,13 @@ namespace testing {
 
 class Message;
 
-// Legacy imports for backwards compatibility.
-// New code should use std:: names directly.
-using std::get;
-using std::make_tuple;
-using std::tuple;
-using std::tuple_element;
-using std::tuple_size;
+// Legacy imports for backwards compatibility. 
+// New code should use std:: names directly. 
+using std::get; 
+using std::make_tuple; 
+using std::tuple; 
+using std::tuple_element; 
+using std::tuple_size; 
 
 namespace internal {
 
@@ -867,26 +867,26 @@ namespace internal {
 // Secret object, which is what we want.
 class Secret;
 
-// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
-// time expression is true (in new code, use static_assert instead). For
-// example, you could use it to verify the size of a static array:
+// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile 
+// time expression is true (in new code, use static_assert instead). For 
+// example, you could use it to verify the size of a static array: 
 //
 //   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
 //                         names_incorrect_size);
 //
-// The second argument to the macro must be a valid C++ identifier. If the
-// expression is false, compiler will issue an error containing this identifier.
-#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+// The second argument to the macro must be a valid C++ identifier. If the 
+// expression is false, compiler will issue an error containing this identifier. 
+#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg) 
 
 // A helper for suppressing warnings on constant condition.  It just
 // returns 'condition'.
 GTEST_API_ bool IsTrue(bool condition);
 
-// Defines RE.
+// Defines RE. 
 
-#if GTEST_USES_PCRE
-// if used, PCRE is injected by custom/gtest-port.h
-#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
+#if GTEST_USES_PCRE 
+// if used, PCRE is injected by custom/gtest-port.h 
+#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE 
 
 // A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
 // Regular Expression syntax.
@@ -905,9 +905,9 @@ class GTEST_API_ RE {
   // Returns the string representation of the regex.
   const char* pattern() const { return pattern_; }
 
-  // FullMatch(str, re) returns true if and only if regular expression re
-  // matches the entire str.
-  // PartialMatch(str, re) returns true if and only if regular expression re
+  // FullMatch(str, re) returns true if and only if regular expression re 
+  // matches the entire str. 
+  // PartialMatch(str, re) returns true if and only if regular expression re 
   // matches a substring of str (including str itself).
   static bool FullMatch(const ::std::string& str, const RE& re) {
     return FullMatch(str.c_str(), re);
@@ -924,20 +924,20 @@ class GTEST_API_ RE {
   const char* pattern_;
   bool is_valid_;
 
-# if GTEST_USES_POSIX_RE
+# if GTEST_USES_POSIX_RE 
 
   regex_t full_regex_;     // For FullMatch().
   regex_t partial_regex_;  // For PartialMatch().
 
-# else  // GTEST_USES_SIMPLE_RE
+# else  // GTEST_USES_SIMPLE_RE 
 
   const char* full_pattern_;  // For FullMatch();
 
-# endif
+# endif 
 };
 
-#endif  // GTEST_USES_PCRE
-
+#endif  // GTEST_USES_PCRE 
+ 
 // Formats a source file path and a line number as they would appear
 // in an error message from the compiler used to compile this code.
 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
@@ -986,7 +986,7 @@ class GTEST_API_ GTestLog {
                                   __FILE__, __LINE__).GetStream()
 
 inline void LogToStderr() {}
-inline void FlushInfoLog() { fflush(nullptr); }
+inline void FlushInfoLog() { fflush(nullptr); } 
 
 #endif  // !defined(GTEST_LOG_)
 
@@ -1023,26 +1023,26 @@ inline void FlushInfoLog() { fflush(nullptr); }
     GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
                       << gtest_error
 
-// Transforms "T" into "const T&" according to standard reference collapsing
-// rules (this is only needed as a backport for C++98 compilers that do not
-// support reference collapsing). Specifically, it transforms:
-//
-//   char         ==> const char&
-//   const char   ==> const char&
-//   char&        ==> char&
-//   const char&  ==> const char&
-//
-// Note that the non-const reference will not have "const" added. This is
-// standard, and necessary so that "T" can always bind to "const T&".
+// Transforms "T" into "const T&" according to standard reference collapsing 
+// rules (this is only needed as a backport for C++98 compilers that do not 
+// support reference collapsing). Specifically, it transforms: 
+// 
+//   char         ==> const char& 
+//   const char   ==> const char& 
+//   char&        ==> char& 
+//   const char&  ==> const char& 
+// 
+// Note that the non-const reference will not have "const" added. This is 
+// standard, and necessary so that "T" can always bind to "const T&". 
 template <typename T>
-struct ConstRef { typedef const T& type; };
-template <typename T>
-struct ConstRef<T&> { typedef T& type; };
-
-// The argument T must depend on some template parameters.
-#define GTEST_REFERENCE_TO_CONST_(T) \
-  typename ::testing::internal::ConstRef<T>::type
-
+struct ConstRef { typedef const T& type; }; 
+template <typename T> 
+struct ConstRef<T&> { typedef T& type; }; 
+
+// The argument T must depend on some template parameters. 
+#define GTEST_REFERENCE_TO_CONST_(T) \ 
+  typename ::testing::internal::ConstRef<T>::type 
+ 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 //
 // Use ImplicitCast_ as a safe version of static_cast for upcasting in
@@ -1096,13 +1096,13 @@ inline To DownCast_(From* f) {  // so we only accept pointers
   GTEST_INTENTIONAL_CONST_COND_PUSH_()
   if (false) {
   GTEST_INTENTIONAL_CONST_COND_POP_()
-  const To to = nullptr;
-  ::testing::internal::ImplicitCast_<From*>(to);
+  const To to = nullptr; 
+  ::testing::internal::ImplicitCast_<From*>(to); 
   }
 
 #if GTEST_HAS_RTTI
   // RTTI: debug mode only!
-  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
+  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr); 
 #endif
   return static_cast<To>(f);
 }
@@ -1148,15 +1148,15 @@ GTEST_API_ size_t GetFileSize(FILE* file);
 GTEST_API_ std::string ReadEntireFile(FILE* file);
 
 // All command line arguments.
-GTEST_API_ std::vector<std::string> GetArgvs();
+GTEST_API_ std::vector<std::string> GetArgvs(); 
 
 #if GTEST_HAS_DEATH_TEST
 
-std::vector<std::string> GetInjectableArgvs();
-// Deprecated: pass the args vector by value instead.
-void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
-void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
-void ClearInjectableArgvs();
+std::vector<std::string> GetInjectableArgvs(); 
+// Deprecated: pass the args vector by value instead. 
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs); 
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs); 
+void ClearInjectableArgvs(); 
 
 #endif  // GTEST_HAS_DEATH_TEST
 
@@ -1171,7 +1171,7 @@ inline void SleepMilliseconds(int n) {
     0,                  // 0 seconds.
     n * 1000L * 1000L,  // And n ms.
   };
-  nanosleep(&time, nullptr);
+  nanosleep(&time, nullptr); 
 }
 # endif  // GTEST_HAS_PTHREAD
 
@@ -1189,7 +1189,7 @@ inline void SleepMilliseconds(int n) {
 class Notification {
  public:
   Notification() : notified_(false) {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); 
   }
   ~Notification() {
     pthread_mutex_destroy(&mutex_);
@@ -1247,8 +1247,8 @@ class GTEST_API_ AutoHandle {
   void Reset(Handle handle);
 
  private:
-  // Returns true if and only if the handle is a valid handle object that can be
-  // closed.
+  // Returns true if and only if the handle is a valid handle object that can be 
+  // closed. 
   bool IsCloseable() const;
 
   Handle handle_;
@@ -1299,7 +1299,7 @@ class ThreadWithParamBase {
 // pass into pthread_create().
 extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
   static_cast<ThreadWithParamBase*>(thread)->Run();
-  return nullptr;
+  return nullptr; 
 }
 
 // Helper class for testing Google Test's multi-threading constructs.
@@ -1328,19 +1328,19 @@ class ThreadWithParam : public ThreadWithParamBase {
     // The thread can be created only after all fields except thread_
     // have been initialized.
     GTEST_CHECK_POSIX_SUCCESS_(
-        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
+        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base)); 
   }
-  ~ThreadWithParam() override { Join(); }
+  ~ThreadWithParam() override { Join(); } 
 
   void Join() {
     if (!finished_) {
-      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr)); 
       finished_ = true;
     }
   }
 
-  void Run() override {
-    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
+  void Run() override { 
+    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification(); 
     func_(param_);
   }
 
@@ -1350,8 +1350,8 @@ class ThreadWithParam : public ThreadWithParamBase {
   // When non-NULL, used to block execution until the controller thread
   // notifies.
   Notification* const thread_can_start_;
-  bool finished_;  // true if and only if we know that the thread function has
-                   // finished.
+  bool finished_;  // true if and only if we know that the thread function has 
+                   // finished. 
   pthread_t thread_;  // The native thread object.
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
@@ -1407,7 +1407,7 @@ class GTEST_API_ Mutex {
   // Initializes owner_thread_id_ and critical_section_ in static mutexes.
   void ThreadSafeLazyInit();
 
-  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
+  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503, 
   // we assume that 0 is an invalid value for thread IDs.
   unsigned int owner_thread_id_;
 
@@ -1415,7 +1415,7 @@ class GTEST_API_ Mutex {
   // by the linker.
   MutexType type_;
   long critical_section_init_phase_;  // NOLINT
-  GTEST_CRITICAL_SECTION* critical_section_;
+  GTEST_CRITICAL_SECTION* critical_section_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
 };
@@ -1616,7 +1616,7 @@ class ThreadLocal : public ThreadLocalBase {
   class DefaultValueHolderFactory : public ValueHolderFactory {
    public:
     DefaultValueHolderFactory() {}
-    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } 
 
    private:
     GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
@@ -1625,7 +1625,7 @@ class ThreadLocal : public ThreadLocalBase {
   class InstanceValueHolderFactory : public ValueHolderFactory {
    public:
     explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    ValueHolder* MakeNewHolder() const override {
+    ValueHolder* MakeNewHolder() const override { 
       return new ValueHolder(value_);
     }
 
@@ -1635,7 +1635,7 @@ class ThreadLocal : public ThreadLocalBase {
     GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
   };
 
-  std::unique_ptr<ValueHolderFactory> default_factory_;
+  std::unique_ptr<ValueHolderFactory> default_factory_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
 };
@@ -1691,20 +1691,20 @@ class MutexBase {
      extern ::testing::internal::MutexBase mutex
 
 // Defines and statically (i.e. at link time) initializes a static mutex.
-// The initialization list here does not explicitly initialize each field,
-// instead relying on default initialization for the unspecified fields. In
-// particular, the owner_ field (a pthread_t) is not explicitly initialized.
-// This allows initialization to work whether pthread_t is a scalar or struct.
-// The flag -Wmissing-field-initializers must not be specified for this to work.
-#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
-  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
+// The initialization list here does not explicitly initialize each field, 
+// instead relying on default initialization for the unspecified fields. In 
+// particular, the owner_ field (a pthread_t) is not explicitly initialized. 
+// This allows initialization to work whether pthread_t is a scalar or struct. 
+// The flag -Wmissing-field-initializers must not be specified for this to work. 
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 
+  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0} 
 
 // The Mutex class can only be used for mutexes created at runtime. It
 // shares its API with MutexBase otherwise.
 class Mutex : public MutexBase {
  public:
   Mutex() {
-    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); 
     has_owner_ = false;
   }
   ~Mutex() {
@@ -1754,7 +1754,7 @@ extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
 
 // Implements thread-local storage on pthreads-based systems.
 template <typename T>
-class GTEST_API_ ThreadLocal {
+class GTEST_API_ ThreadLocal { 
  public:
   ThreadLocal()
       : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
@@ -1802,7 +1802,7 @@ class GTEST_API_ ThreadLocal {
   T* GetOrCreateValue() const {
     ThreadLocalValueHolderBase* const holder =
         static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
-    if (holder != nullptr) {
+    if (holder != nullptr) { 
       return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
     }
 
@@ -1825,7 +1825,7 @@ class GTEST_API_ ThreadLocal {
   class DefaultValueHolderFactory : public ValueHolderFactory {
    public:
     DefaultValueHolderFactory() {}
-    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } 
 
    private:
     GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
@@ -1834,7 +1834,7 @@ class GTEST_API_ ThreadLocal {
   class InstanceValueHolderFactory : public ValueHolderFactory {
    public:
     explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
-    ValueHolder* MakeNewHolder() const override {
+    ValueHolder* MakeNewHolder() const override { 
       return new ValueHolder(value_);
     }
 
@@ -1846,7 +1846,7 @@ class GTEST_API_ ThreadLocal {
 
   // A key pthreads uses for looking up per-thread values.
   const pthread_key_t key_;
-  std::unique_ptr<ValueHolderFactory> default_factory_;
+  std::unique_ptr<ValueHolderFactory> default_factory_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
 };
@@ -1886,7 +1886,7 @@ class GTestMutexLock {
 typedef GTestMutexLock MutexLock;
 
 template <typename T>
-class GTEST_API_ ThreadLocal {
+class GTEST_API_ ThreadLocal { 
  public:
   ThreadLocal() : value_() {}
   explicit ThreadLocal(const T& value) : value_(value) {}
@@ -1940,19 +1940,19 @@ inline bool IsUpper(char ch) {
 inline bool IsXDigit(char ch) {
   return isxdigit(static_cast<unsigned char>(ch)) != 0;
 }
-#ifdef __cpp_char8_t
-inline bool IsXDigit(char8_t ch) {
-  return isxdigit(static_cast<unsigned char>(ch)) != 0;
-}
-#endif
-inline bool IsXDigit(char16_t ch) {
-  const unsigned char low_byte = static_cast<unsigned char>(ch);
-  return ch == low_byte && isxdigit(low_byte) != 0;
-}
-inline bool IsXDigit(char32_t ch) {
-  const unsigned char low_byte = static_cast<unsigned char>(ch);
-  return ch == low_byte && isxdigit(low_byte) != 0;
-}
+#ifdef __cpp_char8_t 
+inline bool IsXDigit(char8_t ch) { 
+  return isxdigit(static_cast<unsigned char>(ch)) != 0; 
+} 
+#endif 
+inline bool IsXDigit(char16_t ch) { 
+  const unsigned char low_byte = static_cast<unsigned char>(ch); 
+  return ch == low_byte && isxdigit(low_byte) != 0; 
+} 
+inline bool IsXDigit(char32_t ch) { 
+  const unsigned char low_byte = static_cast<unsigned char>(ch); 
+  return ch == low_byte && isxdigit(low_byte) != 0; 
+} 
 inline bool IsXDigit(wchar_t ch) {
   const unsigned char low_byte = static_cast<unsigned char>(ch);
   return ch == low_byte && isxdigit(low_byte) != 0;
@@ -1987,16 +1987,16 @@ namespace posix {
 typedef struct _stat StatStruct;
 
 # ifdef __BORLANDC__
-inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int DoIsATTY(int fd) { return isatty(fd); } 
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return stricmp(s1, s2);
 }
 inline char* StrDup(const char* src) { return strdup(src); }
 # else  // !__BORLANDC__
 #  if GTEST_OS_WINDOWS_MOBILE
-inline int DoIsATTY(int /* fd */) { return 0; }
+inline int DoIsATTY(int /* fd */) { return 0; } 
 #  else
-inline int DoIsATTY(int fd) { return _isatty(fd); }
+inline int DoIsATTY(int fd) { return _isatty(fd); } 
 #  endif  // GTEST_OS_WINDOWS_MOBILE
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return _stricmp(s1, s2);
@@ -2017,28 +2017,28 @@ inline bool IsDir(const StatStruct& st) {
 }
 # endif  // GTEST_OS_WINDOWS_MOBILE
 
-#elif GTEST_OS_ESP8266
-typedef struct stat StatStruct;
-
-inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
-inline int Stat(const char* path, StatStruct* buf) {
-  // stat function not implemented on ESP8266
-  return 0;
-}
-inline int StrCaseCmp(const char* s1, const char* s2) {
-  return strcasecmp(s1, s2);
-}
-inline char* StrDup(const char* src) { return strdup(src); }
-inline int RmDir(const char* dir) { return rmdir(dir); }
-inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-
+#elif GTEST_OS_ESP8266 
+typedef struct stat StatStruct; 
+ 
+inline int FileNo(FILE* file) { return fileno(file); } 
+inline int DoIsATTY(int fd) { return isatty(fd); } 
+inline int Stat(const char* path, StatStruct* buf) { 
+  // stat function not implemented on ESP8266 
+  return 0; 
+} 
+inline int StrCaseCmp(const char* s1, const char* s2) { 
+  return strcasecmp(s1, s2); 
+} 
+inline char* StrDup(const char* src) { return strdup(src); } 
+inline int RmDir(const char* dir) { return rmdir(dir); } 
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } 
+ 
 #else
 
 typedef struct stat StatStruct;
 
 inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int DoIsATTY(int fd) { return isatty(fd); } 
 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return strcasecmp(s1, s2);
@@ -2049,39 +2049,39 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 
 #endif  // GTEST_OS_WINDOWS
 
-inline int IsATTY(int fd) {
-  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
-  // to a file on Linux), which is unexpected, so save the previous value, and
-  // restore it after the call.
-  int savedErrno = errno;
-  int isAttyValue = DoIsATTY(fd);
-  errno = savedErrno;
-
-  return isAttyValue;
-}
-
+inline int IsATTY(int fd) { 
+  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout 
+  // to a file on Linux), which is unexpected, so save the previous value, and 
+  // restore it after the call. 
+  int savedErrno = errno; 
+  int isAttyValue = DoIsATTY(fd); 
+  errno = savedErrno; 
+ 
+  return isAttyValue; 
+} 
+ 
 // Functions deprecated by MSVC 8.0.
 
-GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_() 
 
 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
 // StrError() aren't needed on Windows CE at this time and thus not
 // defined there.
 
-#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
-    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \ 
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA 
 inline int ChDir(const char* dir) { return chdir(dir); }
 #endif
 inline FILE* FOpen(const char* path, const char* mode) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
-  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
-  std::wstring_convert<wchar_codecvt> converter;
-  std::wstring wide_path = converter.from_bytes(path);
-  std::wstring wide_mode = converter.from_bytes(mode);
-  return _wfopen(wide_path.c_str(), wide_mode.c_str());
-#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW 
+  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {}; 
+  std::wstring_convert<wchar_codecvt> converter; 
+  std::wstring wide_path = converter.from_bytes(path); 
+  std::wstring wide_mode = converter.from_bytes(mode); 
+  return _wfopen(wide_path.c_str(), wide_mode.c_str()); 
+#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW 
   return fopen(path, mode);
-#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW 
 }
 #if !GTEST_OS_WINDOWS_MOBILE
 inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
@@ -2101,30 +2101,30 @@ inline int Close(int fd) { return close(fd); }
 inline const char* StrError(int errnum) { return strerror(errnum); }
 #endif
 inline const char* GetEnv(const char* name) {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
-    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
-  // We are on an embedded platform, which has no environment variables.
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ 
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA 
+  // We are on an embedded platform, which has no environment variables. 
   static_cast<void>(name);  // To prevent 'unused argument' warning.
-  return nullptr;
+  return nullptr; 
 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
   // Environment variables which we programmatically clear will be set to the
   // empty string rather than unset (NULL).  Handle that case.
   const char* const env = getenv(name);
-  return (env != nullptr && env[0] != '\0') ? env : nullptr;
+  return (env != nullptr && env[0] != '\0') ? env : nullptr; 
 #else
   return getenv(name);
 #endif
 }
 
-GTEST_DISABLE_MSC_DEPRECATED_POP_()
+GTEST_DISABLE_MSC_DEPRECATED_POP_() 
 
 #if GTEST_OS_WINDOWS_MOBILE
 // Windows CE has no C library. The abort() function is used in
 // several places in Google Test. This implementation provides a reasonable
 // imitation of standard behaviour.
-[[noreturn]] void Abort();
+[[noreturn]] void Abort(); 
 #else
-[[noreturn]] inline void Abort() { abort(); }
+[[noreturn]] inline void Abort() { abort(); } 
 #endif  // GTEST_OS_WINDOWS_MOBILE
 
 }  // namespace posix
@@ -2134,25 +2134,25 @@ GTEST_DISABLE_MSC_DEPRECATED_POP_()
 // MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
 // function in order to achieve that.  We use macro definition here because
 // snprintf is a variadic function.
-#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
+#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE 
 // MSVC 2005 and above support variadic macros.
 # define GTEST_SNPRINTF_(buffer, size, format, ...) \
      _snprintf_s(buffer, size, size, format, __VA_ARGS__)
 #elif defined(_MSC_VER)
-// Windows CE does not define _snprintf_s
+// Windows CE does not define _snprintf_s 
 # define GTEST_SNPRINTF_ _snprintf
 #else
 # define GTEST_SNPRINTF_ snprintf
 #endif
 
-// The biggest signed integer type the compiler supports.
+// The biggest signed integer type the compiler supports. 
 //
-// long long is guaranteed to be at least 64-bits in C++11.
-using BiggestInt = long long;  // NOLINT
-
-// The maximum number a BiggestInt can represent.
-constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
+// long long is guaranteed to be at least 64-bits in C++11. 
+using BiggestInt = long long;  // NOLINT 
 
+// The maximum number a BiggestInt can represent. 
+constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)(); 
+ 
 // This template class serves as a compile-time function from size to
 // type.  It maps a size in bytes to a primitive type with that
 // size. e.g.
@@ -2176,27 +2176,27 @@ class TypeWithSize {
  public:
   // This prevents the user from using TypeWithSize<N> with incorrect
   // values of N.
-  using UInt = void;
+  using UInt = void; 
 };
 
 // The specialization for size 4.
 template <>
 class TypeWithSize<4> {
  public:
-  using Int = std::int32_t;
-  using UInt = std::uint32_t;
+  using Int = std::int32_t; 
+  using UInt = std::uint32_t; 
 };
 
 // The specialization for size 8.
 template <>
 class TypeWithSize<8> {
  public:
-  using Int = std::int64_t;
-  using UInt = std::uint64_t;
+  using Int = std::int64_t; 
+  using UInt = std::uint64_t; 
 };
 
 // Integer types of known sizes.
-using TimeInMillis = int64_t;  // Represents time in milliseconds.
+using TimeInMillis = int64_t;  // Represents time in milliseconds. 
 
 // Utilities for command line flags and environment variables.
 
@@ -2215,16 +2215,16 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 // Macros for declaring flags.
 # define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
 # define GTEST_DECLARE_int32_(name) \
-    GTEST_API_ extern std::int32_t GTEST_FLAG(name)
-# define GTEST_DECLARE_string_(name) \
+    GTEST_API_ extern std::int32_t GTEST_FLAG(name) 
+# define GTEST_DECLARE_string_(name) \ 
     GTEST_API_ extern ::std::string GTEST_FLAG(name)
 
 // Macros for defining flags.
-# define GTEST_DEFINE_bool_(name, default_val, doc) \
+# define GTEST_DEFINE_bool_(name, default_val, doc) \ 
     GTEST_API_ bool GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_int32_(name, default_val, doc) \
-    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
-# define GTEST_DEFINE_string_(name, default_val, doc) \
+# define GTEST_DEFINE_int32_(name, default_val, doc) \ 
+    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val) 
+# define GTEST_DEFINE_string_(name, default_val, doc) \ 
     GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
 
 #endif  // !defined(GTEST_DECLARE_bool_)
@@ -2238,152 +2238,152 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
 // to *value and returns true; otherwise leaves *value unchanged and returns
 // false.
-GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,
-                           int32_t* value);
+GTEST_API_ bool ParseInt32(const Message& src_text, const char* str, 
+                           int32_t* value); 
 
-// Parses a bool/int32_t/string from the environment variable
+// Parses a bool/int32_t/string from the environment variable 
 // corresponding to the given Google Test flag.
 bool BoolFromGTestEnv(const char* flag, bool default_val);
-GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);
-std::string OutputFlagAlsoCheckEnvVar();
-const char* StringFromGTestEnv(const char* flag, const char* default_val);
-
-}  // namespace internal
-}  // namespace testing
+GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val); 
+std::string OutputFlagAlsoCheckEnvVar(); 
+const char* StringFromGTestEnv(const char* flag, const char* default_val); 
 
-#if !defined(GTEST_INTERNAL_DEPRECATED)
-
-// Internal Macro to mark an API deprecated, for googletest usage only
-// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
-// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
-// a deprecated entity will trigger a warning when compiled with
-// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
-// For msvc /W3 option will need to be used
-// Note that for 'other' compilers this macro evaluates to nothing to prevent
-// compilations errors.
-#if defined(_MSC_VER)
-#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
-#elif defined(__GNUC__)
-#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
-#else
-#define GTEST_INTERNAL_DEPRECATED(message)
-#endif
-
-#endif  // !defined(GTEST_INTERNAL_DEPRECATED)
-
-#if GTEST_HAS_ABSL
-// Always use absl::any for UniversalPrinter<> specializations if googletest
-// is built with absl support.
-#define GTEST_INTERNAL_HAS_ANY 1
-#error #include "absl/types/any.h"
-namespace testing {
-namespace internal {
-using Any = ::absl::any;
-}  // namespace internal
-}  // namespace testing
-#else
-#ifdef __has_include
-#if __has_include(<any>) && __cplusplus >= 201703L
-// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
-// specializations.
-#define GTEST_INTERNAL_HAS_ANY 1
-#include <any>
-namespace testing {
-namespace internal {
-using Any = ::std::any;
-}  // namespace internal
-}  // namespace testing
-// The case where absl is configured NOT to alias std::any is not
-// supported.
-#endif  // __has_include(<any>) && __cplusplus >= 201703L
-#endif  // __has_include
-#endif  // GTEST_HAS_ABSL
-
-#if GTEST_HAS_ABSL
-// Always use absl::optional for UniversalPrinter<> specializations if
-// googletest is built with absl support.
-#define GTEST_INTERNAL_HAS_OPTIONAL 1
-#error #include "absl/types/optional.h"
-namespace testing {
-namespace internal {
-template <typename T>
-using Optional = ::absl::optional<T>;
-}  // namespace internal
-}  // namespace testing
-#else
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
-// specializations.
-#define GTEST_INTERNAL_HAS_OPTIONAL 1
-#include <optional>
-namespace testing {
-namespace internal {
-template <typename T>
-using Optional = ::std::optional<T>;
-}  // namespace internal
-}  // namespace testing
-// The case where absl is configured NOT to alias std::optional is not
-// supported.
-#endif  // __has_include(<optional>) && __cplusplus >= 201703L
-#endif  // __has_include
-#endif  // GTEST_HAS_ABSL
-
-#if GTEST_HAS_ABSL
-// Always use absl::string_view for Matcher<> specializations if googletest
-// is built with absl support.
-# define GTEST_INTERNAL_HAS_STRING_VIEW 1
-#error #include "absl/strings/string_view.h"
-namespace testing {
-namespace internal {
-using StringView = ::absl::string_view;
-}  // namespace internal
-}  // namespace testing
-#else
-# ifdef __has_include
-#   if __has_include(<string_view>) && __cplusplus >= 201703L
-// Otherwise for C++17 and higher use std::string_view for Matcher<>
-// specializations.
-#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
-#include <string_view>
-namespace testing {
-namespace internal {
-using StringView = ::std::string_view;
-}  // namespace internal
-}  // namespace testing
-// The case where absl is configured NOT to alias std::string_view is not
-// supported.
-#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
-# endif  // __has_include
-#endif  // GTEST_HAS_ABSL
-
-#if GTEST_HAS_ABSL
-// Always use absl::variant for UniversalPrinter<> specializations if googletest
-// is built with absl support.
-#define GTEST_INTERNAL_HAS_VARIANT 1
-#error #include "absl/types/variant.h"
-namespace testing {
-namespace internal {
-template <typename... T>
-using Variant = ::absl::variant<T...>;
-}  // namespace internal
-}  // namespace testing
-#else
-#ifdef __has_include
-#if __has_include(<variant>) && __cplusplus >= 201703L
-// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
-// specializations.
-#define GTEST_INTERNAL_HAS_VARIANT 1
-#include <variant>
-namespace testing {
-namespace internal {
-template <typename... T>
-using Variant = ::std::variant<T...>;
 }  // namespace internal
 }  // namespace testing
-// The case where absl is configured NOT to alias std::variant is not supported.
-#endif  // __has_include(<variant>) && __cplusplus >= 201703L
-#endif  // __has_include
-#endif  // GTEST_HAS_ABSL
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#if !defined(GTEST_INTERNAL_DEPRECATED) 
+ 
+// Internal Macro to mark an API deprecated, for googletest usage only 
+// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or 
+// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of 
+// a deprecated entity will trigger a warning when compiled with 
+// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler). 
+// For msvc /W3 option will need to be used 
+// Note that for 'other' compilers this macro evaluates to nothing to prevent 
+// compilations errors. 
+#if defined(_MSC_VER) 
+#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message)) 
+#elif defined(__GNUC__) 
+#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message))) 
+#else 
+#define GTEST_INTERNAL_DEPRECATED(message) 
+#endif 
+ 
+#endif  // !defined(GTEST_INTERNAL_DEPRECATED) 
+ 
+#if GTEST_HAS_ABSL 
+// Always use absl::any for UniversalPrinter<> specializations if googletest 
+// is built with absl support. 
+#define GTEST_INTERNAL_HAS_ANY 1 
+#error #include "absl/types/any.h" 
+namespace testing { 
+namespace internal { 
+using Any = ::absl::any; 
+}  // namespace internal 
+}  // namespace testing 
+#else 
+#ifdef __has_include 
+#if __has_include(<any>) && __cplusplus >= 201703L 
+// Otherwise for C++17 and higher use std::any for UniversalPrinter<> 
+// specializations. 
+#define GTEST_INTERNAL_HAS_ANY 1 
+#include <any> 
+namespace testing { 
+namespace internal { 
+using Any = ::std::any; 
+}  // namespace internal 
+}  // namespace testing 
+// The case where absl is configured NOT to alias std::any is not 
+// supported. 
+#endif  // __has_include(<any>) && __cplusplus >= 201703L 
+#endif  // __has_include 
+#endif  // GTEST_HAS_ABSL 
+ 
+#if GTEST_HAS_ABSL 
+// Always use absl::optional for UniversalPrinter<> specializations if 
+// googletest is built with absl support. 
+#define GTEST_INTERNAL_HAS_OPTIONAL 1 
+#error #include "absl/types/optional.h" 
+namespace testing { 
+namespace internal { 
+template <typename T> 
+using Optional = ::absl::optional<T>; 
+}  // namespace internal 
+}  // namespace testing 
+#else 
+#ifdef __has_include 
+#if __has_include(<optional>) && __cplusplus >= 201703L 
+// Otherwise for C++17 and higher use std::optional for UniversalPrinter<> 
+// specializations. 
+#define GTEST_INTERNAL_HAS_OPTIONAL 1 
+#include <optional> 
+namespace testing { 
+namespace internal { 
+template <typename T> 
+using Optional = ::std::optional<T>; 
+}  // namespace internal 
+}  // namespace testing 
+// The case where absl is configured NOT to alias std::optional is not 
+// supported. 
+#endif  // __has_include(<optional>) && __cplusplus >= 201703L 
+#endif  // __has_include 
+#endif  // GTEST_HAS_ABSL 
+ 
+#if GTEST_HAS_ABSL 
+// Always use absl::string_view for Matcher<> specializations if googletest 
+// is built with absl support. 
+# define GTEST_INTERNAL_HAS_STRING_VIEW 1 
+#error #include "absl/strings/string_view.h" 
+namespace testing { 
+namespace internal { 
+using StringView = ::absl::string_view; 
+}  // namespace internal 
+}  // namespace testing 
+#else 
+# ifdef __has_include 
+#   if __has_include(<string_view>) && __cplusplus >= 201703L 
+// Otherwise for C++17 and higher use std::string_view for Matcher<> 
+// specializations. 
+#   define GTEST_INTERNAL_HAS_STRING_VIEW 1 
+#include <string_view> 
+namespace testing { 
+namespace internal { 
+using StringView = ::std::string_view; 
+}  // namespace internal 
+}  // namespace testing 
+// The case where absl is configured NOT to alias std::string_view is not 
+// supported. 
+#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L 
+# endif  // __has_include 
+#endif  // GTEST_HAS_ABSL 
+ 
+#if GTEST_HAS_ABSL 
+// Always use absl::variant for UniversalPrinter<> specializations if googletest 
+// is built with absl support. 
+#define GTEST_INTERNAL_HAS_VARIANT 1 
+#error #include "absl/types/variant.h" 
+namespace testing { 
+namespace internal { 
+template <typename... T> 
+using Variant = ::absl::variant<T...>; 
+}  // namespace internal 
+}  // namespace testing 
+#else 
+#ifdef __has_include 
+#if __has_include(<variant>) && __cplusplus >= 201703L 
+// Otherwise for C++17 and higher use std::variant for UniversalPrinter<> 
+// specializations. 
+#define GTEST_INTERNAL_HAS_VARIANT 1 
+#include <variant> 
+namespace testing { 
+namespace internal { 
+template <typename... T> 
+using Variant = ::std::variant<T...>; 
+}  // namespace internal 
+}  // namespace testing 
+// The case where absl is configured NOT to alias std::variant is not supported. 
+#endif  // __has_include(<variant>) && __cplusplus >= 201703L 
+#endif  // __has_include 
+#endif  // GTEST_HAS_ABSL 
+ 
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-string.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-string.h
index 68de72c67f..4dbec33c31 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-string.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-string.h
@@ -27,27 +27,27 @@
 // (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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 //
 // This header file declares the String class and functions used internally by
 // Google Test.  They are subject to change without notice. They should not used
 // by code external to Google Test.
 //
-// This header file is #included by gtest-internal.h.
+// This header file is #included by gtest-internal.h. 
 // It should not be #included by other files.
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ 
 
 #ifdef __BORLANDC__
 // string.h is not guaranteed to provide strcpy on C++ Builder.
-# error #include <mem.h>
+# error #include <mem.h> 
 #endif
 
 #include <string.h>
-#include <cstdint>
+#include <cstdint> 
 #include <string>
 
 #include "gtest/internal/gtest-port.h"
@@ -95,8 +95,8 @@ class GTEST_API_ String {
   static const char* Utf16ToAnsi(LPCWSTR utf16_str);
 #endif
 
-  // Compares two C strings.  Returns true if and only if they have the same
-  // content.
+  // Compares two C strings.  Returns true if and only if they have the same 
+  // content. 
   //
   // Unlike strcmp(), this function can handle NULL argument(s).  A
   // NULL C string is considered different to any non-NULL C string,
@@ -109,16 +109,16 @@ class GTEST_API_ String {
   // returned.
   static std::string ShowWideCString(const wchar_t* wide_c_str);
 
-  // Compares two wide C strings.  Returns true if and only if they have the
-  // same content.
+  // Compares two wide C strings.  Returns true if and only if they have the 
+  // same content. 
   //
   // Unlike wcscmp(), this function can handle NULL argument(s).  A
   // NULL C string is considered different to any non-NULL C string,
   // including the empty string.
   static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
 
-  // Compares two C strings, ignoring case.  Returns true if and only if
-  // they have the same content.
+  // Compares two C strings, ignoring case.  Returns true if and only if 
+  // they have the same content. 
   //
   // Unlike strcasecmp(), this function can handle NULL argument(s).
   // A NULL C string is considered different to any non-NULL C string,
@@ -126,8 +126,8 @@ class GTEST_API_ String {
   static bool CaseInsensitiveCStringEquals(const char* lhs,
                                            const char* rhs);
 
-  // Compares two wide C strings, ignoring case.  Returns true if and only if
-  // they have the same content.
+  // Compares two wide C strings, ignoring case.  Returns true if and only if 
+  // they have the same content. 
   //
   // Unlike wcscasecmp(), this function can handle NULL argument(s).
   // A NULL C string is considered different to any non-NULL wide C string,
@@ -141,23 +141,23 @@ class GTEST_API_ String {
   static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                                const wchar_t* rhs);
 
-  // Returns true if and only if the given string ends with the given suffix,
-  // ignoring case. Any string is considered to end with an empty suffix.
+  // Returns true if and only if the given string ends with the given suffix, 
+  // ignoring case. Any string is considered to end with an empty suffix. 
   static bool EndsWithCaseInsensitive(
       const std::string& str, const std::string& suffix);
 
   // Formats an int value as "%02d".
   static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
 
-  // Formats an int value to given width with leading zeros.
-  static std::string FormatIntWidthN(int value, int width);
-
+  // Formats an int value to given width with leading zeros. 
+  static std::string FormatIntWidthN(int value, int width); 
+ 
   // Formats an int value as "%X".
   static std::string FormatHexInt(int value);
 
-  // Formats an int value as "%X".
-  static std::string FormatHexUInt32(uint32_t value);
-
+  // Formats an int value as "%X". 
+  static std::string FormatHexUInt32(uint32_t value); 
+ 
   // Formats a byte as "%02X".
   static std::string FormatByte(unsigned char value);
 
@@ -172,4 +172,4 @@ GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
 }  // namespace internal
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ 
diff --git a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-type-util.h b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-type-util.h
index b87a2e2cac..4299ab186d 100644
--- a/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ b/contrib/restricted/googletest/googletest/include/gtest/internal/gtest-type-util.h
@@ -28,12 +28,12 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Type utilities needed for implementing typed and type-parameterized
-// tests.
+// tests. 
 
-// GOOGLETEST_CM0001 DO NOT DELETE
-
-#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
-#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+// GOOGLETEST_CM0001 DO NOT DELETE 
+ 
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ 
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ 
 
 #include "gtest/internal/gtest-port.h"
 
@@ -48,57 +48,57 @@
 namespace testing {
 namespace internal {
 
-// Canonicalizes a given name with respect to the Standard C++ Library.
-// This handles removing the inline namespace within `std` that is
-// used by various standard libraries (e.g., `std::__1`).  Names outside
-// of namespace std are returned unmodified.
-inline std::string CanonicalizeForStdLibVersioning(std::string s) {
-  static const char prefix[] = "std::__";
-  if (s.compare(0, strlen(prefix), prefix) == 0) {
-    std::string::size_type end = s.find("::", strlen(prefix));
-    if (end != s.npos) {
-      // Erase everything between the initial `std` and the second `::`.
-      s.erase(strlen("std"), end - strlen("std"));
-    }
-  }
-  return s;
-}
-
-#if GTEST_HAS_RTTI
-// GetTypeName(const std::type_info&) returns a human-readable name of type T.
-inline std::string GetTypeName(const std::type_info& type) {
-  const char* const name = type.name();
-#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+// Canonicalizes a given name with respect to the Standard C++ Library. 
+// This handles removing the inline namespace within `std` that is 
+// used by various standard libraries (e.g., `std::__1`).  Names outside 
+// of namespace std are returned unmodified. 
+inline std::string CanonicalizeForStdLibVersioning(std::string s) { 
+  static const char prefix[] = "std::__"; 
+  if (s.compare(0, strlen(prefix), prefix) == 0) { 
+    std::string::size_type end = s.find("::", strlen(prefix)); 
+    if (end != s.npos) { 
+      // Erase everything between the initial `std` and the second `::`. 
+      s.erase(strlen("std"), end - strlen("std")); 
+    } 
+  } 
+  return s; 
+} 
+ 
+#if GTEST_HAS_RTTI 
+// GetTypeName(const std::type_info&) returns a human-readable name of type T. 
+inline std::string GetTypeName(const std::type_info& type) { 
+  const char* const name = type.name(); 
+#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) 
   int status = 0;
   // gcc's implementation of typeid(T).name() mangles the type name,
   // so we have to demangle it.
-#if GTEST_HAS_CXXABI_H_
+#if GTEST_HAS_CXXABI_H_ 
   using abi::__cxa_demangle;
-#endif  // GTEST_HAS_CXXABI_H_
-  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
+#endif  // GTEST_HAS_CXXABI_H_ 
+  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status); 
   const std::string name_str(status == 0 ? readable_name : name);
   free(readable_name);
-  return CanonicalizeForStdLibVersioning(name_str);
-#else
+  return CanonicalizeForStdLibVersioning(name_str); 
+#else 
   return name;
-#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
-}
-#endif  // GTEST_HAS_RTTI
-
-// GetTypeName<T>() returns a human-readable name of type T if and only if
-// RTTI is enabled, otherwise it returns a dummy type name.
-// NB: This function is also used in Google Mock, so don't move it inside of
-// the typed-test-only section below.
-template <typename T>
-std::string GetTypeName() {
-#if GTEST_HAS_RTTI
-  return GetTypeName(typeid(T));
-#else
+#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC 
+} 
+#endif  // GTEST_HAS_RTTI 
+
+// GetTypeName<T>() returns a human-readable name of type T if and only if 
+// RTTI is enabled, otherwise it returns a dummy type name. 
+// NB: This function is also used in Google Mock, so don't move it inside of 
+// the typed-test-only section below. 
+template <typename T> 
+std::string GetTypeName() { 
+#if GTEST_HAS_RTTI 
+  return GetTypeName(typeid(T)); 
+#else 
   return "<type>";
-#endif  // GTEST_HAS_RTTI
+#endif  // GTEST_HAS_RTTI 
 }
 
-// A unique type indicating an empty node
+// A unique type indicating an empty node 
 struct None {};
 
 # define GTEST_TEMPLATE_ template <typename T> class
@@ -122,62 +122,62 @@ struct TemplateSel {
 # define GTEST_BIND_(TmplSel, T) \
   TmplSel::template Bind<T>::type
 
-template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
-struct Templates {
-  using Head = TemplateSel<Head_>;
-  using Tail = Templates<Tail_...>;
+template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_> 
+struct Templates { 
+  using Head = TemplateSel<Head_>; 
+  using Tail = Templates<Tail_...>; 
 };
 
-template <GTEST_TEMPLATE_ Head_>
-struct Templates<Head_> {
-  using Head = TemplateSel<Head_>;
-  using Tail = None;
+template <GTEST_TEMPLATE_ Head_> 
+struct Templates<Head_> { 
+  using Head = TemplateSel<Head_>; 
+  using Tail = None; 
 };
 
-// Tuple-like type lists
-template <typename Head_, typename... Tail_>
-struct Types {
-  using Head = Head_;
-  using Tail = Types<Tail_...>;
+// Tuple-like type lists 
+template <typename Head_, typename... Tail_> 
+struct Types { 
+  using Head = Head_; 
+  using Tail = Types<Tail_...>; 
 };
 
-template <typename Head_>
-struct Types<Head_> {
-  using Head = Head_;
-  using Tail = None;
+template <typename Head_> 
+struct Types<Head_> { 
+  using Head = Head_; 
+  using Tail = None; 
 };
 
-// Helper metafunctions to tell apart a single type from types
-// generated by ::testing::Types
-template <typename... Ts>
-struct ProxyTypeList {
-  using type = Types<Ts...>;
+// Helper metafunctions to tell apart a single type from types 
+// generated by ::testing::Types 
+template <typename... Ts> 
+struct ProxyTypeList { 
+  using type = Types<Ts...>; 
 };
 
-template <typename>
-struct is_proxy_type_list : std::false_type {};
+template <typename> 
+struct is_proxy_type_list : std::false_type {}; 
 
-template <typename... Ts>
-struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {};
+template <typename... Ts> 
+struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {}; 
 
-// Generator which conditionally creates type lists.
-// It recognizes if a requested type list should be created
-// and prevents creating a new type list nested within another one.
+// Generator which conditionally creates type lists. 
+// It recognizes if a requested type list should be created 
+// and prevents creating a new type list nested within another one. 
 template <typename T>
-struct GenerateTypeList {
- private:
-  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T,
-                                          ProxyTypeList<T>>::type;
+struct GenerateTypeList { 
+ private: 
+  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T, 
+                                          ProxyTypeList<T>>::type; 
 
- public:
-  using type = typename proxy::type;
+ public: 
+  using type = typename proxy::type; 
 };
 
 }  // namespace internal
-
-template <typename... Ts>
-using Types = internal::ProxyTypeList<Ts...>;
-
+ 
+template <typename... Ts> 
+using Types = internal::ProxyTypeList<Ts...>; 
+ 
 }  // namespace testing
 
-#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ 
diff --git a/contrib/restricted/googletest/googletest/src/gtest-all.cc b/contrib/restricted/googletest/googletest/src/gtest-all.cc
index ad292905cf..35b800bc24 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-all.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-all.cc
@@ -26,9 +26,9 @@
 // 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.
-
+ 
 //
-// Google C++ Testing and Mocking Framework (Google Test)
+// Google C++ Testing and Mocking Framework (Google Test) 
 //
 // Sometimes it's desirable to build Google Test by compiling a single file.
 // This file serves this purpose.
@@ -41,7 +41,7 @@
 #include "src/gtest.cc"
 #include "src/gtest-death-test.cc"
 #include "src/gtest-filepath.cc"
-#include "src/gtest-matchers.cc"
+#include "src/gtest-matchers.cc" 
 #include "src/gtest-port.cc"
 #include "src/gtest-printers.cc"
 #include "src/gtest-test-part.cc"
diff --git a/contrib/restricted/googletest/googletest/src/gtest-death-test.cc b/contrib/restricted/googletest/googletest/src/gtest-death-test.cc
index 0d184ad24a..56505cb3f0 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-death-test.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-death-test.cc
@@ -26,15 +26,15 @@
 // 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.
-
+ 
 //
 // This file implements death tests.
 
 #include "gtest/gtest-death-test.h"
-
-#include <functional>
-#include <utility>
-
+ 
+#include <functional> 
+#include <utility> 
+ 
 #include "gtest/internal/gtest-port.h"
 #include "gtest/internal/custom/gtest.h"
 
@@ -65,7 +65,7 @@
 #  include <spawn.h>
 # endif  // GTEST_OS_QNX
 
-# if GTEST_OS_FUCHSIA
+# if GTEST_OS_FUCHSIA 
 #  error #include <lib/fdio/fd.h>
 #  error #include <lib/fdio/io.h>
 #  error #include <lib/fdio/spawn.h>
@@ -77,8 +77,8 @@
 #  error #include <zircon/syscalls.h>
 #  error #include <zircon/syscalls/policy.h>
 #  error #include <zircon/syscalls/port.h>
-# endif  // GTEST_OS_FUCHSIA
-
+# endif  // GTEST_OS_FUCHSIA 
+ 
 #endif  // GTEST_HAS_DEATH_TEST
 
 #include "gtest/gtest-message.h"
@@ -90,11 +90,11 @@ namespace testing {
 // Constants.
 
 // The default death test style.
-//
-// This is defined in internal/gtest-port.h as "fast", but can be overridden by
-// a definition in internal/custom/gtest-port.h. The recommended value, which is
-// used internally at Google, is "threadsafe".
-static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;
+// 
+// This is defined in internal/gtest-port.h as "fast", but can be overridden by 
+// a definition in internal/custom/gtest-port.h. The recommended value, which is 
+// used internally at Google, is "threadsafe". 
+static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE; 
 
 GTEST_DEFINE_string_(
     death_test_style,
@@ -123,8 +123,8 @@ GTEST_DEFINE_string_(
     "Indicates the file, line number, temporal index of "
     "the single death test to run, and a file descriptor to "
     "which a success code may be sent, all separated by "
-    "the '|' characters.  This flag is specified if and only if the "
-    "current process is a sub-process launched for running a thread-safe "
+    "the '|' characters.  This flag is specified if and only if the " 
+    "current process is a sub-process launched for running a thread-safe " 
     "death test.  FOR INTERNAL USE ONLY.");
 }  // namespace internal
 
@@ -134,7 +134,7 @@ namespace internal {
 
 // Valid only for fast death tests. Indicates the code is running in the
 // child process of a fast style death test.
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 static bool g_in_fast_death_test_child = false;
 # endif
 
@@ -144,10 +144,10 @@ static bool g_in_fast_death_test_child = false;
 // tests.  IMPORTANT: This is an internal utility.  Using it may break the
 // implementation of death tests.  User code MUST NOT use it.
 bool InDeathTestChild() {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA 
 
-  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
-  // of the death_test_style flag.
+  // On Windows and Fuchsia, death tests are thread-safe regardless of the value 
+  // of the death_test_style flag. 
   return !GTEST_FLAG(internal_run_death_test).empty();
 
 # else
@@ -167,7 +167,7 @@ ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
 
 // ExitedWithCode function-call operator.
 bool ExitedWithCode::operator()(int exit_status) const {
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA 
 
   return exit_status == exit_code_;
 
@@ -175,10 +175,10 @@ bool ExitedWithCode::operator()(int exit_status) const {
 
   return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
 
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA 
 }
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 // KilledBySignal constructor.
 KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
 }
@@ -195,7 +195,7 @@ bool KilledBySignal::operator()(int exit_status) const {
 #  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
   return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
 }
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 
 namespace internal {
 
@@ -206,7 +206,7 @@ namespace internal {
 static std::string ExitSummary(int exit_code) {
   Message m;
 
-# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA 
 
   m << "Exited with exit status " << exit_code;
 
@@ -222,7 +222,7 @@ static std::string ExitSummary(int exit_code) {
     m << " (core dumped)";
   }
 #  endif
-# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA 
 
   return m.GetString();
 }
@@ -233,7 +233,7 @@ bool ExitedUnsuccessfully(int exit_status) {
   return !ExitedWithCode(0)(exit_status);
 }
 
-# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 // Generates a textual failure message when a death test finds more than
 // one thread running, or cannot determine the number of threads, prior
 // to executing the given statement.  It is the responsibility of the
@@ -242,19 +242,19 @@ static std::string DeathTestThreadWarning(size_t thread_count) {
   Message msg;
   msg << "Death tests use fork(), which is unsafe particularly"
       << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
-  if (thread_count == 0) {
+  if (thread_count == 0) { 
     msg << "couldn't detect the number of threads.";
-  } else {
+  } else { 
     msg << "detected " << thread_count << " threads.";
-  }
-  msg << " See "
-         "https://github.com/google/googletest/blob/master/docs/"
-         "advanced.md#death-tests-and-threads"
-      << " for more explanation and suggested solutions, especially if"
-      << " this is the last message you see before your test times out.";
+  } 
+  msg << " See " 
+         "https://github.com/google/googletest/blob/master/docs/" 
+         "advanced.md#death-tests-and-threads" 
+      << " for more explanation and suggested solutions, especially if" 
+      << " this is the last message you see before your test times out."; 
   return msg.GetString();
 }
-# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA 
 
 // Flag characters for reporting a death test that did not die.
 static const char kDeathTestLived = 'L';
@@ -262,13 +262,13 @@ static const char kDeathTestReturned = 'R';
 static const char kDeathTestThrew = 'T';
 static const char kDeathTestInternalError = 'I';
 
-#if GTEST_OS_FUCHSIA
-
-// File descriptor used for the pipe in the child process.
-static const int kFuchsiaReadPipeFd = 3;
-
-#endif
-
+#if GTEST_OS_FUCHSIA 
+ 
+// File descriptor used for the pipe in the child process. 
+static const int kFuchsiaReadPipeFd = 3; 
+ 
+#endif 
+ 
 // An enumeration describing all of the possible ways that a death test can
 // conclude.  DIED means that the process died while executing the test
 // code; LIVED means that process lived beyond the end of the test code;
@@ -283,13 +283,13 @@ enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
 // message is propagated back to the parent process.  Otherwise, the
 // message is simply printed to stderr.  In either case, the program
 // then exits with status 1.
-static void DeathTestAbort(const std::string& message) {
+static void DeathTestAbort(const std::string& message) { 
   // On a POSIX system, this function may be called from a threadsafe-style
   // death test child process, which operates on a very small stack.  Use
   // the heap for any additional non-minuscule memory requirements.
   const InternalRunDeathTestFlag* const flag =
       GetUnitTestImpl()->internal_run_death_test_flag();
-  if (flag != nullptr) {
+  if (flag != nullptr) { 
     FILE* parent = posix::FDOpen(flag->write_fd(), "w");
     fputc(kDeathTestInternalError, parent);
     fprintf(parent, "%s", message.c_str());
@@ -369,7 +369,7 @@ static void FailFromInternalError(int fd) {
 // for the current test.
 DeathTest::DeathTest() {
   TestInfo* const info = GetUnitTestImpl()->current_test_info();
-  if (info == nullptr) {
+  if (info == nullptr) { 
     DeathTestAbort("Cannot run a death test outside of a TEST or "
                    "TEST_F construct");
   }
@@ -377,11 +377,11 @@ DeathTest::DeathTest() {
 
 // Creates and returns a death test by dispatching to the current
 // death test factory.
-bool DeathTest::Create(const char* statement,
-                       Matcher<const std::string&> matcher, const char* file,
-                       int line, DeathTest** test) {
+bool DeathTest::Create(const char* statement, 
+                       Matcher<const std::string&> matcher, const char* file, 
+                       int line, DeathTest** test) { 
   return GetUnitTestImpl()->death_test_factory()->Create(
-      statement, std::move(matcher), file, line, test);
+      statement, std::move(matcher), file, line, test); 
 }
 
 const char* DeathTest::LastMessage() {
@@ -397,9 +397,9 @@ std::string DeathTest::last_death_test_message_;
 // Provides cross platform implementation for some death functionality.
 class DeathTestImpl : public DeathTest {
  protected:
-  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
+  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher) 
       : statement_(a_statement),
-        matcher_(std::move(matcher)),
+        matcher_(std::move(matcher)), 
         spawned_(false),
         status_(-1),
         outcome_(IN_PROGRESS),
@@ -407,10 +407,10 @@ class DeathTestImpl : public DeathTest {
         write_fd_(-1) {}
 
   // read_fd_ is expected to be closed and cleared by a derived class.
-  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
+  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } 
 
-  void Abort(AbortReason reason) override;
-  bool Passed(bool status_ok) override;
+  void Abort(AbortReason reason) override; 
+  bool Passed(bool status_ok) override; 
 
   const char* statement() const { return statement_; }
   bool spawned() const { return spawned_; }
@@ -430,15 +430,15 @@ class DeathTestImpl : public DeathTest {
   // case of unexpected codes.
   void ReadAndInterpretStatusByte();
 
-  // Returns stderr output from the child process.
-  virtual std::string GetErrorLogs();
-
+  // Returns stderr output from the child process. 
+  virtual std::string GetErrorLogs(); 
+ 
  private:
   // The textual content of the code this object is testing.  This class
   // doesn't own this string and should not attempt to delete it.
   const char* const statement_;
-  // A matcher that's expected to match the stderr output by the child process.
-  Matcher<const std::string&> matcher_;
+  // A matcher that's expected to match the stderr output by the child process. 
+  Matcher<const std::string&> matcher_; 
   // True if the death test child process has been successfully spawned.
   bool spawned_;
   // The exit status of the child process.
@@ -500,10 +500,10 @@ void DeathTestImpl::ReadAndInterpretStatusByte() {
   set_read_fd(-1);
 }
 
-std::string DeathTestImpl::GetErrorLogs() {
-  return GetCapturedStderr();
-}
-
+std::string DeathTestImpl::GetErrorLogs() { 
+  return GetCapturedStderr(); 
+} 
+ 
 // Signals that the death test code which should have exited, didn't.
 // Should be called only in a death test child process.
 // Writes a status byte to the child's status file descriptor, then
@@ -557,21 +557,21 @@ static ::std::string FormatDeathTestOutput(const ::std::string& output) {
 //             in the format specified by wait(2). On Windows, this is the
 //             value supplied to the ExitProcess() API or a numeric code
 //             of the exception that terminated the program.
-//   matcher_: A matcher that's expected to match the stderr output by the child
-//             process.
+//   matcher_: A matcher that's expected to match the stderr output by the child 
+//             process. 
 //
 // Argument:
 //   status_ok: true if exit_status is acceptable in the context of
 //              this particular death test, which fails if it is false
 //
-// Returns true if and only if all of the above conditions are met.  Otherwise,
-// the first failing condition, in the order given above, is the one that is
+// Returns true if and only if all of the above conditions are met.  Otherwise, 
+// the first failing condition, in the order given above, is the one that is 
 // reported. Also sets the last death test message string.
 bool DeathTestImpl::Passed(bool status_ok) {
   if (!spawned())
     return false;
 
-  const std::string error_message = GetErrorLogs();
+  const std::string error_message = GetErrorLogs(); 
 
   bool success = false;
   Message buffer;
@@ -592,15 +592,15 @@ bool DeathTestImpl::Passed(bool status_ok) {
       break;
     case DIED:
       if (status_ok) {
-        if (matcher_.Matches(error_message)) {
+        if (matcher_.Matches(error_message)) { 
           success = true;
         } else {
-          std::ostringstream stream;
-          matcher_.DescribeTo(&stream);
+          std::ostringstream stream; 
+          matcher_.DescribeTo(&stream); 
           buffer << "    Result: died but not with expected error.\n"
-                 << "  Expected: " << stream.str() << "\n"
-                 << "Actual msg:\n"
-                 << FormatDeathTestOutput(error_message);
+                 << "  Expected: " << stream.str() << "\n" 
+                 << "Actual msg:\n" 
+                 << FormatDeathTestOutput(error_message); 
         }
       } else {
         buffer << "    Result: died but not with expected exit code:\n"
@@ -649,11 +649,11 @@ bool DeathTestImpl::Passed(bool status_ok) {
 //
 class WindowsDeathTest : public DeathTestImpl {
  public:
-  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                   const char* file, int line)
-      : DeathTestImpl(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
+  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher, 
+                   const char* file, int line) 
+      : DeathTestImpl(a_statement, std::move(matcher)), 
+        file_(file), 
+        line_(line) {} 
 
   // All of these virtual functions are inherited from DeathTest.
   virtual int Wait();
@@ -730,7 +730,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   const TestInfo* const info = impl->current_test_info();
   const int death_test_index = info->result()->death_test_count();
 
-  if (flag != nullptr) {
+  if (flag != nullptr) { 
     // ParseInternalRunDeathTestFlag() has performed all the necessary
     // processing.
     set_write_fd(flag->write_fd());
@@ -739,8 +739,8 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
 
   // WindowsDeathTest uses an anonymous pipe to communicate results of
   // a death test.
-  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
-                                                 nullptr, TRUE};
+  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES), 
+                                                 nullptr, TRUE}; 
   HANDLE read_handle, write_handle;
   GTEST_DEATH_TEST_CHECK_(
       ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
@@ -751,13 +751,13 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   write_handle_.Reset(write_handle);
   event_handle_.Reset(::CreateEvent(
       &handles_are_inheritable,
-      TRUE,       // The event will automatically reset to non-signaled state.
-      FALSE,      // The initial state is non-signalled.
-      nullptr));  // The even is unnamed.
-  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
+      TRUE,       // The event will automatically reset to non-signaled state. 
+      FALSE,      // The initial state is non-signalled. 
+      nullptr));  // The even is unnamed. 
+  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr); 
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + 
+                                  kFilterFlag + "=" + info->test_suite_name() + 
+                                  "." + info->name(); 
   const std::string internal_flag =
       std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
       "=" + file_ + "|" + StreamableToString(line_) + "|" +
@@ -770,9 +770,9 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
       "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
 
   char executable_path[_MAX_PATH + 1];  // NOLINT
-  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
-                                                                executable_path,
-                                                                _MAX_PATH));
+  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr, 
+                                                                executable_path, 
+                                                                _MAX_PATH)); 
 
   std::string command_line =
       std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
@@ -793,288 +793,288 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
   startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
 
   PROCESS_INFORMATION process_info;
-  GTEST_DEATH_TEST_CHECK_(
-      ::CreateProcessA(
-          executable_path, const_cast<char*>(command_line.c_str()),
-          nullptr,  // Retuned process handle is not inheritable.
-          nullptr,  // Retuned thread handle is not inheritable.
-          TRUE,  // Child inherits all inheritable handles (for write_handle_).
-          0x0,   // Default creation flags.
-          nullptr,  // Inherit the parent's environment.
-          UnitTest::GetInstance()->original_working_dir(), &startup_info,
-          &process_info) != FALSE);
+  GTEST_DEATH_TEST_CHECK_( 
+      ::CreateProcessA( 
+          executable_path, const_cast<char*>(command_line.c_str()), 
+          nullptr,  // Retuned process handle is not inheritable. 
+          nullptr,  // Retuned thread handle is not inheritable. 
+          TRUE,  // Child inherits all inheritable handles (for write_handle_). 
+          0x0,   // Default creation flags. 
+          nullptr,  // Inherit the parent's environment. 
+          UnitTest::GetInstance()->original_working_dir(), &startup_info, 
+          &process_info) != FALSE); 
   child_handle_.Reset(process_info.hProcess);
   ::CloseHandle(process_info.hThread);
   set_spawned(true);
   return OVERSEE_TEST;
 }
 
-# elif GTEST_OS_FUCHSIA
-
-class FuchsiaDeathTest : public DeathTestImpl {
- public:
-  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                   const char* file, int line)
-      : DeathTestImpl(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
-
-  // All of these virtual functions are inherited from DeathTest.
-  int Wait() override;
-  TestRole AssumeRole() override;
-  std::string GetErrorLogs() override;
-
- private:
-  // The name of the file in which the death test is located.
-  const char* const file_;
-  // The line number on which the death test is located.
-  const int line_;
-  // The stderr data captured by the child process.
-  std::string captured_stderr_;
-
-  zx::process child_process_;
-  zx::channel exception_channel_;
-  zx::socket stderr_socket_;
-};
-
-// Utility class for accumulating command-line arguments.
-class Arguments {
- public:
-  Arguments() { args_.push_back(nullptr); }
-
-  ~Arguments() {
-    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
-         ++i) {
-      free(*i);
-    }
-  }
-  void AddArgument(const char* argument) {
-    args_.insert(args_.end() - 1, posix::StrDup(argument));
-  }
-
-  template <typename Str>
-  void AddArguments(const ::std::vector<Str>& arguments) {
-    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
-         i != arguments.end();
-         ++i) {
-      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
-    }
-  }
-  char* const* Argv() {
-    return &args_[0];
-  }
-
-  int size() {
-    return static_cast<int>(args_.size()) - 1;
-  }
-
- private:
-  std::vector<char*> args_;
-};
-
-// Waits for the child in a death test to exit, returning its exit
-// status, or 0 if no child process exists.  As a side effect, sets the
-// outcome data member.
-int FuchsiaDeathTest::Wait() {
-  const int kProcessKey = 0;
-  const int kSocketKey = 1;
-  const int kExceptionKey = 2;
-
-  if (!spawned())
-    return 0;
-
-  // Create a port to wait for socket/task/exception events.
-  zx_status_t status_zx;
-  zx::port port;
-  status_zx = zx::port::create(0, &port);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  // Register to wait for the child process to terminate.
-  status_zx = child_process_.wait_async(
-      port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  // Register to wait for the socket to be readable or closed.
-  status_zx = stderr_socket_.wait_async(
-      port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  // Register to wait for an exception.
-  status_zx = exception_channel_.wait_async(
-      port, kExceptionKey, ZX_CHANNEL_READABLE, 0);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  bool process_terminated = false;
-  bool socket_closed = false;
-  do {
-    zx_port_packet_t packet = {};
-    status_zx = port.wait(zx::time::infinite(), &packet);
-    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-    if (packet.key == kExceptionKey) {
-      // Process encountered an exception. Kill it directly rather than
-      // letting other handlers process the event. We will get a kProcessKey
-      // event when the process actually terminates.
-      status_zx = child_process_.kill();
-      GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-    } else if (packet.key == kProcessKey) {
-      // Process terminated.
-      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
-      GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
-      process_terminated = true;
-    } else if (packet.key == kSocketKey) {
-      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
-      if (packet.signal.observed & ZX_SOCKET_READABLE) {
-        // Read data from the socket.
-        constexpr size_t kBufferSize = 1024;
-        do {
-          size_t old_length = captured_stderr_.length();
-          size_t bytes_read = 0;
-          captured_stderr_.resize(old_length + kBufferSize);
-          status_zx = stderr_socket_.read(
-              0, &captured_stderr_.front() + old_length, kBufferSize,
-              &bytes_read);
-          captured_stderr_.resize(old_length + bytes_read);
-        } while (status_zx == ZX_OK);
-        if (status_zx == ZX_ERR_PEER_CLOSED) {
-          socket_closed = true;
-        } else {
-          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
-          status_zx = stderr_socket_.wait_async(
-              port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
-          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-        }
-      } else {
-        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED);
-        socket_closed = true;
-      }
-    }
-  } while (!process_terminated && !socket_closed);
-
-  ReadAndInterpretStatusByte();
-
-  zx_info_process_t buffer;
-  status_zx = child_process_.get_info(ZX_INFO_PROCESS, &buffer, sizeof(buffer),
-                                      nullptr, nullptr);
-  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
-
-  GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED);
-  set_status(static_cast<int>(buffer.return_code));
-  return status();
-}
-
-// The AssumeRole process for a Fuchsia death test.  It creates a child
-// process with the same executable as the current process to run the
-// death test.  The child process is given the --gtest_filter and
-// --gtest_internal_run_death_test flags such that it knows to run the
-// current death test only.
-DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
-  const UnitTestImpl* const impl = GetUnitTestImpl();
-  const InternalRunDeathTestFlag* const flag =
-      impl->internal_run_death_test_flag();
-  const TestInfo* const info = impl->current_test_info();
-  const int death_test_index = info->result()->death_test_count();
-
-  if (flag != nullptr) {
-    // ParseInternalRunDeathTestFlag() has performed all the necessary
-    // processing.
-    set_write_fd(kFuchsiaReadPipeFd);
-    return EXECUTE_TEST;
-  }
-
-  // Flush the log buffers since the log streams are shared with the child.
-  FlushInfoLog();
-
-  // Build the child process command line.
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
-  const std::string internal_flag =
-      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
-      + file_ + "|"
-      + StreamableToString(line_) + "|"
-      + StreamableToString(death_test_index);
-  Arguments args;
-  args.AddArguments(GetInjectableArgvs());
-  args.AddArgument(filter_flag.c_str());
-  args.AddArgument(internal_flag.c_str());
-
-  // Build the pipe for communication with the child.
-  zx_status_t status;
-  zx_handle_t child_pipe_handle;
-  int child_pipe_fd;
-  status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-  set_read_fd(child_pipe_fd);
-
-  // Set the pipe handle for the child.
-  fdio_spawn_action_t spawn_actions[2] = {};
-  fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
-  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
-  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
-  add_handle_action->h.handle = child_pipe_handle;
-
-  // Create a socket pair will be used to receive the child process' stderr.
-  zx::socket stderr_producer_socket;
-  status =
-      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
-  GTEST_DEATH_TEST_CHECK_(status >= 0);
-  int stderr_producer_fd = -1;
-  status =
-      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd);
-  GTEST_DEATH_TEST_CHECK_(status >= 0);
-
-  // Make the stderr socket nonblocking.
-  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);
-
-  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
-  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
-  add_stderr_action->fd.local_fd = stderr_producer_fd;
-  add_stderr_action->fd.target_fd = STDERR_FILENO;
-
-  // Create a child job.
-  zx_handle_t child_job = ZX_HANDLE_INVALID;
-  status = zx_job_create(zx_job_default(), 0, & child_job);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-  zx_policy_basic_t policy;
-  policy.condition = ZX_POL_NEW_ANY;
-  policy.policy = ZX_POL_ACTION_ALLOW;
-  status = zx_job_set_policy(
-      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  // Create an exception channel attached to the |child_job|, to allow
-  // us to suppress the system default exception handler from firing.
-  status =
-      zx_task_create_exception_channel(
-          child_job, 0, exception_channel_.reset_and_get_address());
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  // Spawn the child process.
-  status = fdio_spawn_etc(
-      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
-      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
-  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
-
-  set_spawned(true);
-  return OVERSEE_TEST;
-}
-
-std::string FuchsiaDeathTest::GetErrorLogs() {
-  return captured_stderr_;
-}
-
-#else  // We are neither on Windows, nor on Fuchsia.
-
+# elif GTEST_OS_FUCHSIA 
+ 
+class FuchsiaDeathTest : public DeathTestImpl { 
+ public: 
+  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher, 
+                   const char* file, int line) 
+      : DeathTestImpl(a_statement, std::move(matcher)), 
+        file_(file), 
+        line_(line) {} 
+ 
+  // All of these virtual functions are inherited from DeathTest. 
+  int Wait() override; 
+  TestRole AssumeRole() override; 
+  std::string GetErrorLogs() override; 
+ 
+ private: 
+  // The name of the file in which the death test is located. 
+  const char* const file_; 
+  // The line number on which the death test is located. 
+  const int line_; 
+  // The stderr data captured by the child process. 
+  std::string captured_stderr_; 
+ 
+  zx::process child_process_; 
+  zx::channel exception_channel_; 
+  zx::socket stderr_socket_; 
+}; 
+ 
+// Utility class for accumulating command-line arguments. 
+class Arguments { 
+ public: 
+  Arguments() { args_.push_back(nullptr); } 
+ 
+  ~Arguments() { 
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); 
+         ++i) { 
+      free(*i); 
+    } 
+  } 
+  void AddArgument(const char* argument) { 
+    args_.insert(args_.end() - 1, posix::StrDup(argument)); 
+  } 
+ 
+  template <typename Str> 
+  void AddArguments(const ::std::vector<Str>& arguments) { 
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); 
+         i != arguments.end(); 
+         ++i) { 
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); 
+    } 
+  } 
+  char* const* Argv() { 
+    return &args_[0]; 
+  } 
+ 
+  int size() { 
+    return static_cast<int>(args_.size()) - 1; 
+  } 
+ 
+ private: 
+  std::vector<char*> args_; 
+}; 
+ 
+// Waits for the child in a death test to exit, returning its exit 
+// status, or 0 if no child process exists.  As a side effect, sets the 
+// outcome data member. 
+int FuchsiaDeathTest::Wait() { 
+  const int kProcessKey = 0; 
+  const int kSocketKey = 1; 
+  const int kExceptionKey = 2; 
+ 
+  if (!spawned()) 
+    return 0; 
+ 
+  // Create a port to wait for socket/task/exception events. 
+  zx_status_t status_zx; 
+  zx::port port; 
+  status_zx = zx::port::create(0, &port); 
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+  // Register to wait for the child process to terminate. 
+  status_zx = child_process_.wait_async( 
+      port, kProcessKey, ZX_PROCESS_TERMINATED, 0); 
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+  // Register to wait for the socket to be readable or closed. 
+  status_zx = stderr_socket_.wait_async( 
+      port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0); 
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+  // Register to wait for an exception. 
+  status_zx = exception_channel_.wait_async( 
+      port, kExceptionKey, ZX_CHANNEL_READABLE, 0); 
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+  bool process_terminated = false; 
+  bool socket_closed = false; 
+  do { 
+    zx_port_packet_t packet = {}; 
+    status_zx = port.wait(zx::time::infinite(), &packet); 
+    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+    if (packet.key == kExceptionKey) { 
+      // Process encountered an exception. Kill it directly rather than 
+      // letting other handlers process the event. We will get a kProcessKey 
+      // event when the process actually terminates. 
+      status_zx = child_process_.kill(); 
+      GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+    } else if (packet.key == kProcessKey) { 
+      // Process terminated. 
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type)); 
+      GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED); 
+      process_terminated = true; 
+    } else if (packet.key == kSocketKey) { 
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type)); 
+      if (packet.signal.observed & ZX_SOCKET_READABLE) { 
+        // Read data from the socket. 
+        constexpr size_t kBufferSize = 1024; 
+        do { 
+          size_t old_length = captured_stderr_.length(); 
+          size_t bytes_read = 0; 
+          captured_stderr_.resize(old_length + kBufferSize); 
+          status_zx = stderr_socket_.read( 
+              0, &captured_stderr_.front() + old_length, kBufferSize, 
+              &bytes_read); 
+          captured_stderr_.resize(old_length + bytes_read); 
+        } while (status_zx == ZX_OK); 
+        if (status_zx == ZX_ERR_PEER_CLOSED) { 
+          socket_closed = true; 
+        } else { 
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT); 
+          status_zx = stderr_socket_.wait_async( 
+              port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0); 
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+        } 
+      } else { 
+        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED); 
+        socket_closed = true; 
+      } 
+    } 
+  } while (!process_terminated && !socket_closed); 
+ 
+  ReadAndInterpretStatusByte(); 
+ 
+  zx_info_process_t buffer; 
+  status_zx = child_process_.get_info(ZX_INFO_PROCESS, &buffer, sizeof(buffer), 
+                                      nullptr, nullptr); 
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK); 
+ 
+  GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED); 
+  set_status(static_cast<int>(buffer.return_code)); 
+  return status(); 
+} 
+ 
+// The AssumeRole process for a Fuchsia death test.  It creates a child 
+// process with the same executable as the current process to run the 
+// death test.  The child process is given the --gtest_filter and 
+// --gtest_internal_run_death_test flags such that it knows to run the 
+// current death test only. 
+DeathTest::TestRole FuchsiaDeathTest::AssumeRole() { 
+  const UnitTestImpl* const impl = GetUnitTestImpl(); 
+  const InternalRunDeathTestFlag* const flag = 
+      impl->internal_run_death_test_flag(); 
+  const TestInfo* const info = impl->current_test_info(); 
+  const int death_test_index = info->result()->death_test_count(); 
+ 
+  if (flag != nullptr) { 
+    // ParseInternalRunDeathTestFlag() has performed all the necessary 
+    // processing. 
+    set_write_fd(kFuchsiaReadPipeFd); 
+    return EXECUTE_TEST; 
+  } 
+ 
+  // Flush the log buffers since the log streams are shared with the child. 
+  FlushInfoLog(); 
+ 
+  // Build the child process command line. 
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + 
+                                  kFilterFlag + "=" + info->test_suite_name() + 
+                                  "." + info->name(); 
+  const std::string internal_flag = 
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" 
+      + file_ + "|" 
+      + StreamableToString(line_) + "|" 
+      + StreamableToString(death_test_index); 
+  Arguments args; 
+  args.AddArguments(GetInjectableArgvs()); 
+  args.AddArgument(filter_flag.c_str()); 
+  args.AddArgument(internal_flag.c_str()); 
+ 
+  // Build the pipe for communication with the child. 
+  zx_status_t status; 
+  zx_handle_t child_pipe_handle; 
+  int child_pipe_fd; 
+  status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle); 
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK); 
+  set_read_fd(child_pipe_fd); 
+ 
+  // Set the pipe handle for the child. 
+  fdio_spawn_action_t spawn_actions[2] = {}; 
+  fdio_spawn_action_t* add_handle_action = &spawn_actions[0]; 
+  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE; 
+  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd); 
+  add_handle_action->h.handle = child_pipe_handle; 
+ 
+  // Create a socket pair will be used to receive the child process' stderr. 
+  zx::socket stderr_producer_socket; 
+  status = 
+      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_); 
+  GTEST_DEATH_TEST_CHECK_(status >= 0); 
+  int stderr_producer_fd = -1; 
+  status = 
+      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd); 
+  GTEST_DEATH_TEST_CHECK_(status >= 0); 
+ 
+  // Make the stderr socket nonblocking. 
+  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0); 
+ 
+  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1]; 
+  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD; 
+  add_stderr_action->fd.local_fd = stderr_producer_fd; 
+  add_stderr_action->fd.target_fd = STDERR_FILENO; 
+ 
+  // Create a child job. 
+  zx_handle_t child_job = ZX_HANDLE_INVALID; 
+  status = zx_job_create(zx_job_default(), 0, & child_job); 
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK); 
+  zx_policy_basic_t policy; 
+  policy.condition = ZX_POL_NEW_ANY; 
+  policy.policy = ZX_POL_ACTION_ALLOW; 
+  status = zx_job_set_policy( 
+      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1); 
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK); 
+ 
+  // Create an exception channel attached to the |child_job|, to allow 
+  // us to suppress the system default exception handler from firing. 
+  status = 
+      zx_task_create_exception_channel( 
+          child_job, 0, exception_channel_.reset_and_get_address()); 
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK); 
+ 
+  // Spawn the child process. 
+  status = fdio_spawn_etc( 
+      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr, 
+      2, spawn_actions, child_process_.reset_and_get_address(), nullptr); 
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK); 
+ 
+  set_spawned(true); 
+  return OVERSEE_TEST; 
+} 
+ 
+std::string FuchsiaDeathTest::GetErrorLogs() { 
+  return captured_stderr_; 
+} 
+ 
+#else  // We are neither on Windows, nor on Fuchsia. 
+ 
 // ForkingDeathTest provides implementations for most of the abstract
 // methods of the DeathTest interface.  Only the AssumeRole method is
 // left undefined.
 class ForkingDeathTest : public DeathTestImpl {
  public:
-  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher);
+  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher); 
 
   // All of these virtual functions are inherited from DeathTest.
-  int Wait() override;
+  int Wait() override; 
 
  protected:
   void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
@@ -1085,9 +1085,9 @@ class ForkingDeathTest : public DeathTestImpl {
 };
 
 // Constructs a ForkingDeathTest.
-ForkingDeathTest::ForkingDeathTest(const char* a_statement,
-                                   Matcher<const std::string&> matcher)
-    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}
+ForkingDeathTest::ForkingDeathTest(const char* a_statement, 
+                                   Matcher<const std::string&> matcher) 
+    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {} 
 
 // Waits for the child in a death test to exit, returning its exit
 // status, or 0 if no child process exists.  As a side effect, sets the
@@ -1108,9 +1108,9 @@ int ForkingDeathTest::Wait() {
 // in the child process.
 class NoExecDeathTest : public ForkingDeathTest {
  public:
-  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
-      : ForkingDeathTest(a_statement, std::move(matcher)) {}
-  TestRole AssumeRole() override;
+  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher) 
+      : ForkingDeathTest(a_statement, std::move(matcher)) {} 
+  TestRole AssumeRole() override; 
 };
 
 // The AssumeRole process for a fork-and-run death test.  It implements a
@@ -1163,18 +1163,18 @@ DeathTest::TestRole NoExecDeathTest::AssumeRole() {
 // only this specific death test to be run.
 class ExecDeathTest : public ForkingDeathTest {
  public:
-  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
-                const char* file, int line)
-      : ForkingDeathTest(a_statement, std::move(matcher)),
-        file_(file),
-        line_(line) {}
-  TestRole AssumeRole() override;
-
+  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher, 
+                const char* file, int line) 
+      : ForkingDeathTest(a_statement, std::move(matcher)), 
+        file_(file), 
+        line_(line) {} 
+  TestRole AssumeRole() override; 
+ 
  private:
-  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
-    ::std::vector<std::string> args = GetInjectableArgvs();
+  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() { 
+    ::std::vector<std::string> args = GetInjectableArgvs(); 
 #  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
-    ::std::vector<std::string> extra_args =
+    ::std::vector<std::string> extra_args = 
         GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
     args.insert(args.end(), extra_args.begin(), extra_args.end());
 #  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
@@ -1189,7 +1189,7 @@ class ExecDeathTest : public ForkingDeathTest {
 // Utility class for accumulating command-line arguments.
 class Arguments {
  public:
-  Arguments() { args_.push_back(nullptr); }
+  Arguments() { args_.push_back(nullptr); } 
 
   ~Arguments() {
     for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
@@ -1224,9 +1224,9 @@ struct ExecDeathTestArgs {
   int close_fd;       // File descriptor to close; the read end of a pipe
 };
 
-#  if GTEST_OS_QNX
+#  if GTEST_OS_QNX 
 extern "C" char** environ;
-#  else  // GTEST_OS_QNX
+#  else  // GTEST_OS_QNX 
 // The main function for a threadsafe-style death test child process.
 // This function is called in a clone()-ed process and thus must avoid
 // any potentially unsafe operations like malloc or libc functions.
@@ -1246,20 +1246,20 @@ static int ExecDeathTestChildMain(void* child_arg) {
     return EXIT_FAILURE;
   }
 
-  // We can safely call execv() as it's almost a direct system call. We
+  // We can safely call execv() as it's almost a direct system call. We 
   // cannot use execvp() as it's a libc function and thus potentially
-  // unsafe.  Since execv() doesn't search the PATH, the user must
+  // unsafe.  Since execv() doesn't search the PATH, the user must 
   // invoke the test program via a valid path that contains at least
   // one path separator.
-  execv(args->argv[0], args->argv);
-  DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
+  execv(args->argv[0], args->argv); 
+  DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " + 
                  original_dir + " failed: " +
                  GetLastErrnoDescription());
   return EXIT_FAILURE;
 }
-#  endif  // GTEST_OS_QNX
+#  endif  // GTEST_OS_QNX 
 
-#  if GTEST_HAS_CLONE
+#  if GTEST_HAS_CLONE 
 // Two utility routines that together determine the direction the stack
 // grows.
 // This could be accomplished more elegantly by a single recursive
@@ -1269,31 +1269,31 @@ static int ExecDeathTestChildMain(void* child_arg) {
 // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
 // StackLowerThanAddress into StackGrowsDown, which then doesn't give
 // correct answer.
-static void StackLowerThanAddress(const void* ptr,
-                                  bool* result) GTEST_NO_INLINE_;
-// Make sure sanitizers do not tamper with the stack here.
-// Ideally, we want to use `__builtin_frame_address` instead of a local variable
-// address with sanitizer disabled, but it does not work when the
-// compiler optimizes the stack frame out, which happens on PowerPC targets.
-// HWAddressSanitizer add a random tag to the MSB of the local variable address,
-// making comparison result unpredictable.
-GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-static void StackLowerThanAddress(const void* ptr, bool* result) {
-  int dummy = 0;
-  *result = std::less<const void*>()(&dummy, ptr);
+static void StackLowerThanAddress(const void* ptr, 
+                                  bool* result) GTEST_NO_INLINE_; 
+// Make sure sanitizers do not tamper with the stack here. 
+// Ideally, we want to use `__builtin_frame_address` instead of a local variable 
+// address with sanitizer disabled, but it does not work when the 
+// compiler optimizes the stack frame out, which happens on PowerPC targets. 
+// HWAddressSanitizer add a random tag to the MSB of the local variable address, 
+// making comparison result unpredictable. 
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
+static void StackLowerThanAddress(const void* ptr, bool* result) { 
+  int dummy = 0; 
+  *result = std::less<const void*>()(&dummy, ptr); 
 }
 
 // Make sure AddressSanitizer does not tamper with the stack here.
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
-static bool StackGrowsDown() {
-  int dummy = 0;
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
+static bool StackGrowsDown() { 
+  int dummy = 0; 
   bool result;
   StackLowerThanAddress(&dummy, &result);
   return result;
 }
-#  endif  // GTEST_HAS_CLONE
+#  endif  // GTEST_HAS_CLONE 
 
 // Spawns a child process with the same executable as the current process in
 // a thread-safe manner and instructs it to run the death test.  The
@@ -1331,7 +1331,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
                                         fd_flags | FD_CLOEXEC));
   struct inheritance inherit = {0};
   // spawn is a system call.
-  child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
+  child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ); 
   // Restores the current working directory.
   GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
   GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
@@ -1355,9 +1355,9 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 
   if (!use_fork) {
     static const bool stack_grows_down = StackGrowsDown();
-    const auto stack_size = static_cast<size_t>(getpagesize() * 2);
+    const auto stack_size = static_cast<size_t>(getpagesize() * 2); 
     // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
-    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
+    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE, 
                              MAP_ANON | MAP_PRIVATE, -1, 0);
     GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
 
@@ -1371,9 +1371,9 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
     void* const stack_top =
         static_cast<char*>(stack) +
             (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
-    GTEST_DEATH_TEST_CHECK_(
-        static_cast<size_t>(stack_size) > kMaxStackAlignment &&
-        reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
+    GTEST_DEATH_TEST_CHECK_( 
+        static_cast<size_t>(stack_size) > kMaxStackAlignment && 
+        reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0); 
 
     child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
 
@@ -1390,7 +1390,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 #  endif  // GTEST_OS_QNX
 #  if GTEST_OS_LINUX
   GTEST_DEATH_TEST_CHECK_SYSCALL_(
-      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
+      sigaction(SIGPROF, &saved_sigprof_action, nullptr)); 
 #  endif  // GTEST_OS_LINUX
 
   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
@@ -1408,7 +1408,7 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
   const TestInfo* const info = impl->current_test_info();
   const int death_test_index = info->result()->death_test_count();
 
-  if (flag != nullptr) {
+  if (flag != nullptr) { 
     set_write_fd(flag->write_fd());
     return EXECUTE_TEST;
   }
@@ -1419,9 +1419,9 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
   // it be closed when the child process does an exec:
   GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
 
-  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
-                                  kFilterFlag + "=" + info->test_suite_name() +
-                                  "." + info->name();
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + 
+                                  kFilterFlag + "=" + info->test_suite_name() + 
+                                  "." + info->name(); 
   const std::string internal_flag =
       std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
       + file_ + "|" + StreamableToString(line_) + "|"
@@ -1454,8 +1454,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
 // by the "test" argument to its address.  If the test should be
 // skipped, sets that pointer to NULL.  Returns true, unless the
 // flag is set to an invalid value.
-bool DefaultDeathTestFactory::Create(const char* statement,
-                                     Matcher<const std::string&> matcher,
+bool DefaultDeathTestFactory::Create(const char* statement, 
+                                     Matcher<const std::string&> matcher, 
                                      const char* file, int line,
                                      DeathTest** test) {
   UnitTestImpl* const impl = GetUnitTestImpl();
@@ -1464,7 +1464,7 @@ bool DefaultDeathTestFactory::Create(const char* statement,
   const int death_test_index = impl->current_test_info()
       ->increment_death_test_count();
 
-  if (flag != nullptr) {
+  if (flag != nullptr) { 
     if (death_test_index > flag->index()) {
       DeathTest::set_last_death_test_message(
           "Death test count (" + StreamableToString(death_test_index)
@@ -1475,7 +1475,7 @@ bool DefaultDeathTestFactory::Create(const char* statement,
 
     if (!(flag->file() == file && flag->line() == line &&
           flag->index() == death_test_index)) {
-      *test = nullptr;
+      *test = nullptr; 
       return true;
     }
   }
@@ -1484,22 +1484,22 @@ bool DefaultDeathTestFactory::Create(const char* statement,
 
   if (GTEST_FLAG(death_test_style) == "threadsafe" ||
       GTEST_FLAG(death_test_style) == "fast") {
-    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
-  }
-
-# elif GTEST_OS_FUCHSIA
-
-  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
-      GTEST_FLAG(death_test_style) == "fast") {
-    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
+    *test = new WindowsDeathTest(statement, std::move(matcher), file, line); 
   }
 
+# elif GTEST_OS_FUCHSIA 
+ 
+  if (GTEST_FLAG(death_test_style) == "threadsafe" || 
+      GTEST_FLAG(death_test_style) == "fast") { 
+    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line); 
+  } 
+ 
 # else
 
   if (GTEST_FLAG(death_test_style) == "threadsafe") {
-    *test = new ExecDeathTest(statement, std::move(matcher), file, line);
+    *test = new ExecDeathTest(statement, std::move(matcher), file, line); 
   } else if (GTEST_FLAG(death_test_style) == "fast") {
-    *test = new NoExecDeathTest(statement, std::move(matcher));
+    *test = new NoExecDeathTest(statement, std::move(matcher)); 
   }
 
 # endif  // GTEST_OS_WINDOWS
@@ -1518,7 +1518,7 @@ bool DefaultDeathTestFactory::Create(const char* statement,
 // Recreates the pipe and event handles from the provided parameters,
 // signals the event, and returns a file descriptor wrapped around the pipe
 // handle. This function is called in the child process only.
-static int GetStatusFileDescriptor(unsigned int parent_process_id,
+static int GetStatusFileDescriptor(unsigned int parent_process_id, 
                             size_t write_handle_as_size_t,
                             size_t event_handle_as_size_t) {
   AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
@@ -1535,7 +1535,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
       reinterpret_cast<HANDLE>(write_handle_as_size_t);
   HANDLE dup_write_handle;
 
-  // The newly initialized handle is accessible only in the parent
+  // The newly initialized handle is accessible only in the parent 
   // process. To obtain one accessible within the child, we need to use
   // DuplicateHandle.
   if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
@@ -1584,7 +1584,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
 // initialized from the GTEST_FLAG(internal_run_death_test) flag if
 // the flag is specified; otherwise returns NULL.
 InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
-  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
+  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr; 
 
   // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
   // can use it here.
@@ -1612,16 +1612,16 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
   write_fd = GetStatusFileDescriptor(parent_process_id,
                                      write_handle_as_size_t,
                                      event_handle_as_size_t);
-
-# elif GTEST_OS_FUCHSIA
-
-  if (fields.size() != 3
-      || !ParseNaturalNumber(fields[1], &line)
-      || !ParseNaturalNumber(fields[2], &index)) {
-    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
-        + GTEST_FLAG(internal_run_death_test));
-  }
-
+ 
+# elif GTEST_OS_FUCHSIA 
+ 
+  if (fields.size() != 3 
+      || !ParseNaturalNumber(fields[1], &line) 
+      || !ParseNaturalNumber(fields[2], &index)) { 
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " 
+        + GTEST_FLAG(internal_run_death_test)); 
+  } 
+ 
 # else
 
   if (fields.size() != 4
diff --git a/contrib/restricted/googletest/googletest/src/gtest-filepath.cc b/contrib/restricted/googletest/googletest/src/gtest-filepath.cc
index 0b5629401b..f3c3050f1a 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-filepath.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-filepath.cc
@@ -30,8 +30,8 @@
 #include "gtest/internal/gtest-filepath.h"
 
 #include <stdlib.h>
-#include "gtest/internal/gtest-port.h"
-#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-port.h" 
+#include "gtest/gtest-message.h" 
 
 #if GTEST_OS_WINDOWS_MOBILE
 # include <windows.h>
@@ -43,8 +43,8 @@
 # include <climits>  // Some Linux distributions define PATH_MAX here.
 #endif  // GTEST_OS_WINDOWS_MOBILE
 
-#include "gtest/internal/gtest-string.h"
-
+#include "gtest/internal/gtest-string.h" 
+ 
 #if GTEST_OS_WINDOWS
 # define GTEST_PATH_MAX_ _MAX_PATH
 #elif defined(PATH_MAX)
@@ -92,15 +92,15 @@ static bool IsPathSeparator(char c) {
 
 // Returns the current working directory, or "" if unsuccessful.
 FilePath FilePath::GetCurrentDir() {
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
-    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
-    GTEST_OS_XTENSA
-  // These platforms do not have a current directory, so we just return
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \ 
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \ 
+    GTEST_OS_XTENSA 
+  // These platforms do not have a current directory, so we just return 
   // something reasonable.
   return FilePath(kCurrentDirectoryString);
 #elif GTEST_OS_WINDOWS
   char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
-  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
+  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd); 
 #else
   char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
   char* result = getcwd(cwd, sizeof(cwd));
@@ -108,9 +108,9 @@ FilePath FilePath::GetCurrentDir() {
   // getcwd will likely fail in NaCl due to the sandbox, so return something
   // reasonable. The user may have provided a shim implementation for getcwd,
   // however, so fallback only when failure is detected.
-  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
+  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd); 
 # endif  // GTEST_OS_NACL
-  return FilePath(result == nullptr ? "" : cwd);
+  return FilePath(result == nullptr ? "" : cwd); 
 #endif  // GTEST_OS_WINDOWS_MOBILE
 }
 
@@ -127,7 +127,7 @@ FilePath FilePath::RemoveExtension(const char* extension) const {
   return *this;
 }
 
-// Returns a pointer to the last occurrence of a valid path separator in
+// Returns a pointer to the last occurrence of a valid path separator in 
 // the FilePath. On Windows, for example, both '/' and '\' are valid path
 // separators. Returns NULL if no path separator was found.
 const char* FilePath::FindLastPathSeparator() const {
@@ -135,8 +135,8 @@ const char* FilePath::FindLastPathSeparator() const {
 #if GTEST_HAS_ALT_PATH_SEP_
   const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
   // Comparing two pointers of which only one is NULL is undefined.
-  if (last_alt_sep != nullptr &&
-      (last_sep == nullptr || last_alt_sep > last_sep)) {
+  if (last_alt_sep != nullptr && 
+      (last_sep == nullptr || last_alt_sep > last_sep)) { 
     return last_alt_sep;
   }
 #endif
@@ -164,7 +164,7 @@ FilePath FilePath::RemoveFileName() const {
   const char* const last_sep = FindLastPathSeparator();
   std::string dir;
   if (last_sep) {
-    dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
+    dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str())); 
   } else {
     dir = kCurrentDirectoryString;
   }
@@ -210,7 +210,7 @@ bool FilePath::FileOrDirectoryExists() const {
   delete [] unicode;
   return attributes != kInvalidFileAttributes;
 #else
-  posix::StatStruct file_stat{};
+  posix::StatStruct file_stat{}; 
   return posix::Stat(pathname_.c_str(), &file_stat) == 0;
 #endif  // GTEST_OS_WINDOWS_MOBILE
 }
@@ -237,7 +237,7 @@ bool FilePath::DirectoryExists() const {
     result = true;
   }
 #else
-  posix::StatStruct file_stat{};
+  posix::StatStruct file_stat{}; 
   result = posix::Stat(path.c_str(), &file_stat) == 0 &&
       posix::IsDir(file_stat);
 #endif  // GTEST_OS_WINDOWS_MOBILE
@@ -320,13 +320,13 @@ bool FilePath::CreateFolder() const {
 #if GTEST_OS_WINDOWS_MOBILE
   FilePath removed_sep(this->RemoveTrailingPathSeparator());
   LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
-  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
+  int result = CreateDirectory(unicode, nullptr) ? 0 : -1; 
   delete [] unicode;
 #elif GTEST_OS_WINDOWS
   int result = _mkdir(pathname_.c_str());
-#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
-  // do nothing
-  int result = 0;
+#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA 
+  // do nothing 
+  int result = 0; 
 #else
   int result = mkdir(pathname_.c_str(), 0777);
 #endif  // GTEST_OS_WINDOWS_MOBILE
@@ -350,19 +350,19 @@ FilePath FilePath::RemoveTrailingPathSeparator() const {
 // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
 // redundancies that might be in a pathname involving "." or "..".
 void FilePath::Normalize() {
-  auto out = pathname_.begin();
+  auto out = pathname_.begin(); 
 
-  for (const char character : pathname_) {
-    if (!IsPathSeparator(character)) {
-      *(out++) = character;
-    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
-      *(out++) = kPathSeparator;
+  for (const char character : pathname_) { 
+    if (!IsPathSeparator(character)) { 
+      *(out++) = character; 
+    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) { 
+      *(out++) = kPathSeparator; 
     } else {
-      continue;
+      continue; 
     }
   }
-
-  pathname_.erase(out, pathname_.end());
+ 
+  pathname_.erase(out, pathname_.end()); 
 }
 
 }  // namespace internal
diff --git a/contrib/restricted/googletest/googletest/src/gtest-internal-inl.h b/contrib/restricted/googletest/googletest/src/gtest-internal-inl.h
index 6d8cecbbb3..61a97f30ce 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-internal-inl.h
+++ b/contrib/restricted/googletest/googletest/src/gtest-internal-inl.h
@@ -27,12 +27,12 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-// Utility functions and classes used by the Google C++ testing framework.//
+// Utility functions and classes used by the Google C++ testing framework.// 
 // This file contains purely Google Test's internal implementation.  Please
 // DO NOT #INCLUDE IT IN A USER PROGRAM.
 
-#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
-#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ 
+#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ 
 
 #ifndef _WIN32_WCE
 # include <errno.h>
@@ -42,8 +42,8 @@
 #include <string.h>  // For memmove.
 
 #include <algorithm>
-#include <cstdint>
-#include <memory>
+#include <cstdint> 
+#include <memory> 
 #include <string>
 #include <vector>
 
@@ -58,12 +58,12 @@
 # include <windows.h>  // NOLINT
 #endif  // GTEST_OS_WINDOWS
 
-#include "gtest/gtest.h"
+#include "gtest/gtest.h" 
 #include "gtest/gtest-spi.h"
 
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
-/* class A needs to have dll-interface to be used by clients of class B */)
-
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ 
+/* class A needs to have dll-interface to be used by clients of class B */) 
+ 
 namespace testing {
 
 // Declares the flags.
@@ -84,13 +84,13 @@ const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
 const char kBreakOnFailureFlag[] = "break_on_failure";
 const char kCatchExceptionsFlag[] = "catch_exceptions";
 const char kColorFlag[] = "color";
-const char kFailFast[] = "fail_fast";
+const char kFailFast[] = "fail_fast"; 
 const char kFilterFlag[] = "filter";
 const char kListTestsFlag[] = "list_tests";
 const char kOutputFlag[] = "output";
-const char kBriefFlag[] = "brief";
+const char kBriefFlag[] = "brief"; 
 const char kPrintTimeFlag[] = "print_time";
-const char kPrintUTF8Flag[] = "print_utf8";
+const char kPrintUTF8Flag[] = "print_utf8"; 
 const char kRandomSeedFlag[] = "random_seed";
 const char kRepeatFlag[] = "repeat";
 const char kShuffleFlag[] = "shuffle";
@@ -102,14 +102,14 @@ const char kFlagfileFlag[] = "flagfile";
 // A valid random seed must be in [1, kMaxRandomSeed].
 const int kMaxRandomSeed = 99999;
 
-// g_help_flag is true if and only if the --help flag or an equivalent form
-// is specified on the command line.
+// g_help_flag is true if and only if the --help flag or an equivalent form 
+// is specified on the command line. 
 GTEST_API_ extern bool g_help_flag;
 
 // Returns the current time in milliseconds.
 GTEST_API_ TimeInMillis GetTimeInMillis();
 
-// Returns true if and only if Google Test should use colors in the output.
+// Returns true if and only if Google Test should use colors in the output. 
 GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
 
 // Formats the given time in milliseconds as seconds.
@@ -126,11 +126,11 @@ GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
 GTEST_API_ bool ParseInt32Flag(
-    const char* str, const char* flag, int32_t* value);
+    const char* str, const char* flag, int32_t* value); 
 
 // Returns a random seed in range [1, kMaxRandomSeed] based on the
 // given --gtest_random_seed flag value.
-inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
+inline int GetRandomSeedFromFlag(int32_t random_seed_flag) { 
   const unsigned int raw_seed = (random_seed_flag == 0) ?
       static_cast<unsigned int>(GetTimeInMillis()) :
       static_cast<unsigned int>(random_seed_flag);
@@ -166,14 +166,14 @@ class GTestFlagSaver {
     color_ = GTEST_FLAG(color);
     death_test_style_ = GTEST_FLAG(death_test_style);
     death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    fail_fast_ = GTEST_FLAG(fail_fast);
+    fail_fast_ = GTEST_FLAG(fail_fast); 
     filter_ = GTEST_FLAG(filter);
     internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
     list_tests_ = GTEST_FLAG(list_tests);
     output_ = GTEST_FLAG(output);
-    brief_ = GTEST_FLAG(brief);
+    brief_ = GTEST_FLAG(brief); 
     print_time_ = GTEST_FLAG(print_time);
-    print_utf8_ = GTEST_FLAG(print_utf8);
+    print_utf8_ = GTEST_FLAG(print_utf8); 
     random_seed_ = GTEST_FLAG(random_seed);
     repeat_ = GTEST_FLAG(repeat);
     shuffle_ = GTEST_FLAG(shuffle);
@@ -191,13 +191,13 @@ class GTestFlagSaver {
     GTEST_FLAG(death_test_style) = death_test_style_;
     GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
     GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(fail_fast) = fail_fast_;
+    GTEST_FLAG(fail_fast) = fail_fast_; 
     GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
     GTEST_FLAG(list_tests) = list_tests_;
     GTEST_FLAG(output) = output_;
-    GTEST_FLAG(brief) = brief_;
+    GTEST_FLAG(brief) = brief_; 
     GTEST_FLAG(print_time) = print_time_;
-    GTEST_FLAG(print_utf8) = print_utf8_;
+    GTEST_FLAG(print_utf8) = print_utf8_; 
     GTEST_FLAG(random_seed) = random_seed_;
     GTEST_FLAG(repeat) = repeat_;
     GTEST_FLAG(shuffle) = shuffle_;
@@ -214,18 +214,18 @@ class GTestFlagSaver {
   std::string color_;
   std::string death_test_style_;
   bool death_test_use_fork_;
-  bool fail_fast_;
+  bool fail_fast_; 
   std::string filter_;
   std::string internal_run_death_test_;
   bool list_tests_;
   std::string output_;
-  bool brief_;
+  bool brief_; 
   bool print_time_;
-  bool print_utf8_;
-  int32_t random_seed_;
-  int32_t repeat_;
+  bool print_utf8_; 
+  int32_t random_seed_; 
+  int32_t repeat_; 
   bool shuffle_;
-  int32_t stack_trace_depth_;
+  int32_t stack_trace_depth_; 
   std::string stream_result_to_;
   bool throw_on_failure_;
 } GTEST_ATTRIBUTE_UNUSED_;
@@ -236,11 +236,11 @@ class GTestFlagSaver {
 // If the code_point is not a valid Unicode code point
 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
 // to "(Invalid Unicode 0xXXXXXXXX)".
-GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);
+GTEST_API_ std::string CodePointToUtf8(uint32_t code_point); 
 
 // Converts a wide string to a narrow string in UTF-8 encoding.
 // The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin) 
 //   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
 // Parameter str points to a null-terminated wide string.
 // Parameter num_chars may additionally limit the number
@@ -269,14 +269,14 @@ GTEST_API_ bool ShouldShard(const char* total_shards_str,
                             const char* shard_index_str,
                             bool in_subprocess_for_death_test);
 
-// Parses the environment variable var as a 32-bit integer. If it is unset,
-// returns default_val. If it is not a 32-bit integer, prints an error and
+// Parses the environment variable var as a 32-bit integer. If it is unset, 
+// returns default_val. If it is not a 32-bit integer, prints an error and 
 // and aborts.
-GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);
+GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val); 
 
 // Given the total number of shards, the shard index, and the test id,
-// returns true if and only if the test should be run on this shard. The test id
-// is some arbitrary but unique non-negative integer assigned to each test
+// returns true if and only if the test should be run on this shard. The test id 
+// is some arbitrary but unique non-negative integer assigned to each test 
 // method. Assumes that 0 <= shard_index < total_shards.
 GTEST_API_ bool ShouldRunTestOnShard(
     int total_shards, int shard_index, int test_id);
@@ -307,8 +307,8 @@ void ForEach(const Container& c, Functor functor) {
 // in range [0, v.size()).
 template <typename E>
 inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
-  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
-                                                    : v[static_cast<size_t>(i)];
+  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value 
+                                                    : v[static_cast<size_t>(i)]; 
 }
 
 // Performs an in-place shuffle of a range of the vector's elements.
@@ -330,11 +330,11 @@ void ShuffleRange(internal::Random* random, int begin, int end,
   // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
   for (int range_width = end - begin; range_width >= 2; range_width--) {
     const int last_in_range = begin + range_width - 1;
-    const int selected =
-        begin +
-        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
-    std::swap((*v)[static_cast<size_t>(selected)],
-              (*v)[static_cast<size_t>(last_in_range)]);
+    const int selected = 
+        begin + 
+        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width))); 
+    std::swap((*v)[static_cast<size_t>(selected)], 
+              (*v)[static_cast<size_t>(last_in_range)]); 
   }
 }
 
@@ -361,7 +361,7 @@ class TestPropertyKeyIs {
   // TestPropertyKeyIs has NO default constructor.
   explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
 
-  // Returns true if and only if the test name of test property matches on key_.
+  // Returns true if and only if the test name of test property matches on key_. 
   bool operator()(const TestProperty& test_property) const {
     return test_property.key() == key_;
   }
@@ -394,10 +394,10 @@ class GTEST_API_ UnitTestOptions {
 
   // Functions for processing the gtest_filter flag.
 
-  // Returns true if and only if the user-specified filter matches the test
-  // suite name and the test name.
-  static bool FilterMatchesTest(const std::string& test_suite_name,
-                                const std::string& test_name);
+  // Returns true if and only if the user-specified filter matches the test 
+  // suite name and the test name. 
+  static bool FilterMatchesTest(const std::string& test_suite_name, 
+                                const std::string& test_name); 
 
 #if GTEST_OS_WINDOWS
   // Function for supporting the gtest_catch_exception flag.
@@ -429,7 +429,7 @@ class OsStackTraceGetterInterface {
   //                in the trace.
   //   skip_count - the number of top frames to be skipped; doesn't count
   //                against max_depth.
-  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;
+  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0; 
 
   // UponLeavingGTest() should be called immediately before Google Test calls
   // user code. It saves some information about the current stack that
@@ -449,20 +449,20 @@ class OsStackTraceGetter : public OsStackTraceGetterInterface {
  public:
   OsStackTraceGetter() {}
 
-  std::string CurrentStackTrace(int max_depth, int skip_count) override;
-  void UponLeavingGTest() override;
+  std::string CurrentStackTrace(int max_depth, int skip_count) override; 
+  void UponLeavingGTest() override; 
 
  private:
-#if GTEST_HAS_ABSL
-  Mutex mutex_;  // Protects all internal state.
-
-  // We save the stack frame below the frame that calls user code.
-  // We do this because the address of the frame immediately below
-  // the user code changes between the call to UponLeavingGTest()
-  // and any calls to the stack trace code from within the user code.
-  void* caller_frame_ = nullptr;
-#endif  // GTEST_HAS_ABSL
-
+#if GTEST_HAS_ABSL 
+  Mutex mutex_;  // Protects all internal state. 
+ 
+  // We save the stack frame below the frame that calls user code. 
+  // We do this because the address of the frame immediately below 
+  // the user code changes between the call to UponLeavingGTest() 
+  // and any calls to the stack trace code from within the user code. 
+  void* caller_frame_ = nullptr; 
+#endif  // GTEST_HAS_ABSL 
+ 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
 };
 
@@ -481,7 +481,7 @@ class DefaultGlobalTestPartResultReporter
   explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
   // Implements the TestPartResultReporterInterface. Reports the test part
   // result in the current test.
-  void ReportTestPartResult(const TestPartResult& result) override;
+  void ReportTestPartResult(const TestPartResult& result) override; 
 
  private:
   UnitTestImpl* const unit_test_;
@@ -497,7 +497,7 @@ class DefaultPerThreadTestPartResultReporter
   explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
   // Implements the TestPartResultReporterInterface. The implementation just
   // delegates to the current global test part result reporter of *unit_test_.
-  void ReportTestPartResult(const TestPartResult& result) override;
+  void ReportTestPartResult(const TestPartResult& result) override; 
 
  private:
   UnitTestImpl* const unit_test_;
@@ -535,25 +535,25 @@ class GTEST_API_ UnitTestImpl {
   void SetTestPartResultReporterForCurrentThread(
       TestPartResultReporterInterface* reporter);
 
-  // Gets the number of successful test suites.
-  int successful_test_suite_count() const;
+  // 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 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. 
+  int total_test_suite_count() const; 
 
-  // Gets the number of all test suites that contain at least one test
+  // Gets the number of all test suites that contain at least one test 
   // that should run.
-  int test_suite_to_run_count() const;
+  int test_suite_to_run_count() const; 
 
   // 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 skipped tests. 
+  int skipped_test_count() const; 
+ 
   // Gets the number of failed tests.
   int failed_test_count() const;
 
@@ -579,33 +579,33 @@ class GTEST_API_ UnitTestImpl {
   // Gets the elapsed time, in milliseconds.
   TimeInMillis elapsed_time() const { return elapsed_time_; }
 
-  // Returns true if and only if the unit test passed (i.e. all test suites
-  // passed).
+  // Returns true if and only if the unit test passed (i.e. all test suites 
+  // passed). 
   bool Passed() const { return !Failed(); }
 
-  // Returns true if and only if the unit test failed (i.e. some test suite
-  // failed or something outside of all tests failed).
+  // Returns true if and only if the unit test failed (i.e. some test suite 
+  // failed or something outside of all tests failed). 
   bool Failed() const {
-    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
+    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed(); 
   }
 
-  // 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 {
-    const int index = GetElementOr(test_suite_indices_, i, -1);
-    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
+  // 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 { 
+    const int index = GetElementOr(test_suite_indices_, i, -1); 
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)]; 
   }
 
-  //  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  // 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* GetMutableSuiteCase(int i) {
-    const int index = GetElementOr(test_suite_indices_, i, -1);
-    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
+  //  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); } 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+  // 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* GetMutableSuiteCase(int i) { 
+    const int index = GetElementOr(test_suite_indices_, i, -1); 
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)]; 
   }
 
   // Provides access to the event listener list.
@@ -642,40 +642,40 @@ class GTEST_API_ UnitTestImpl {
   // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
   std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
 
-  // Finds and returns a TestSuite with the given name.  If one doesn't
+  // Finds and returns a TestSuite with the given name.  If one doesn't 
   // exist, creates one and returns it.
   //
   // Arguments:
   //
-  //   test_suite_name: name of the test suite
-  //   type_param:      the name of the test's type parameter, or NULL if
-  //                    this is not a typed or 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* GetTestSuite(const char* test_suite_name, const char* type_param,
-                          internal::SetUpTestSuiteFunc set_up_tc,
-                          internal::TearDownTestSuiteFunc tear_down_tc);
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
-                        internal::SetUpTestSuiteFunc set_up_tc,
-                        internal::TearDownTestSuiteFunc tear_down_tc) {
-    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
-  }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
+  //   test_suite_name: name of the test suite 
+  //   type_param:      the name of the test's type parameter, or NULL if 
+  //                    this is not a typed or 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* GetTestSuite(const char* test_suite_name, const char* type_param, 
+                          internal::SetUpTestSuiteFunc set_up_tc, 
+                          internal::TearDownTestSuiteFunc tear_down_tc); 
+
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  TestCase* GetTestCase(const char* test_case_name, const char* type_param, 
+                        internal::SetUpTestSuiteFunc set_up_tc, 
+                        internal::TearDownTestSuiteFunc tear_down_tc) { 
+    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc); 
+  } 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
   // Adds a TestInfo to the unit test.
   //
   // Arguments:
   //
-  //   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
+  //   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 
   //   test_info:    the TestInfo object
-  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
-                   internal::TearDownTestSuiteFunc tear_down_tc,
+  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, 
+                   internal::TearDownTestSuiteFunc tear_down_tc, 
                    TestInfo* test_info) {
-#if GTEST_HAS_DEATH_TEST
+#if GTEST_HAS_DEATH_TEST 
     // In order to support thread-safe death tests, we need to
     // remember the original working directory when the test program
     // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
@@ -688,33 +688,33 @@ class GTEST_API_ UnitTestImpl {
       GTEST_CHECK_(!original_working_dir_.IsEmpty())
           << "Failed to get the current working directory.";
     }
-#endif  // GTEST_HAS_DEATH_TEST
+#endif  // GTEST_HAS_DEATH_TEST 
 
-    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
-                 set_up_tc, tear_down_tc)
-        ->AddTestInfo(test_info);
+    GetTestSuite(test_info->test_suite_name(), test_info->type_param(), 
+                 set_up_tc, tear_down_tc) 
+        ->AddTestInfo(test_info); 
   }
 
-  // Returns ParameterizedTestSuiteRegistry object used to keep track of
+  // Returns ParameterizedTestSuiteRegistry object used to keep track of 
   // value-parameterized tests and instantiate and register them.
-  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() { 
     return parameterized_test_registry_;
   }
 
-  std::set<std::string>* ignored_parameterized_test_suites() {
-    return &ignored_parameterized_test_suites_;
-  }
-
-  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of
-  // type-parameterized tests and instantiations of them.
-  internal::TypeParameterizedTestSuiteRegistry&
-  type_parameterized_test_registry() {
-    return type_parameterized_test_registry_;
-  }
-
-  // Sets the TestSuite object for the test that's currently running.
-  void set_current_test_suite(TestSuite* a_current_test_suite) {
-    current_test_suite_ = a_current_test_suite;
+  std::set<std::string>* ignored_parameterized_test_suites() { 
+    return &ignored_parameterized_test_suites_; 
+  } 
+ 
+  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of 
+  // type-parameterized tests and instantiations of them. 
+  internal::TypeParameterizedTestSuiteRegistry& 
+  type_parameterized_test_registry() { 
+    return type_parameterized_test_registry_; 
+  } 
+ 
+  // Sets the TestSuite object for the test that's currently running. 
+  void set_current_test_suite(TestSuite* a_current_test_suite) { 
+    current_test_suite_ = a_current_test_suite; 
   }
 
   // Sets the TestInfo object for the test that's currently running.  If
@@ -725,7 +725,7 @@ class GTEST_API_ UnitTestImpl {
   }
 
   // Registers all parameterized tests defined using TEST_P and
-  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
+  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter 
   // combination. This method can be called more then once; it has guards
   // protecting from registering the tests more then once.  If
   // value-parameterized tests are disabled, RegisterParameterizedTests is
@@ -740,7 +740,7 @@ class GTEST_API_ UnitTestImpl {
 
   // Clears the results of all tests, except the ad hoc tests.
   void ClearNonAdHocTestResult() {
-    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
+    ForEach(test_suites_, TestSuite::ClearTestSuiteResult); 
   }
 
   // Clears the results of ad-hoc test assertions.
@@ -749,7 +749,7 @@ class GTEST_API_ UnitTestImpl {
   }
 
   // Adds a TestProperty to the current TestResult object when invoked in a
-  // context of a test or a test suite, or to the global property set. If the
+  // context of a test or a test suite, or to the global property set. If the 
   // result already contains a property with the same key, the value will be
   // updated.
   void RecordProperty(const TestProperty& test_property);
@@ -761,7 +761,7 @@ class GTEST_API_ UnitTestImpl {
 
   // Matches the full name of each test against the user-specified
   // filter to decide whether the test should run, then records the
-  // result in each TestSuite and TestInfo object.
+  // result in each TestSuite and TestInfo object. 
   // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
   // based on sharding variables in the environment.
   // Returns the number of tests that should run.
@@ -770,7 +770,7 @@ class GTEST_API_ UnitTestImpl {
   // Prints the names of the tests matching the user-specified filter flag.
   void ListTestsMatchingFilter();
 
-  const TestSuite* current_test_suite() const { return current_test_suite_; }
+  const TestSuite* current_test_suite() const { return current_test_suite_; } 
   TestInfo* current_test_info() { return current_test_info_; }
   const TestInfo* current_test_info() const { return current_test_info_; }
 
@@ -831,11 +831,11 @@ class GTEST_API_ UnitTestImpl {
   // Gets the random number generator.
   internal::Random* random() { return &random_; }
 
-  // Shuffles all test suites, and the tests within each test suite,
+  // Shuffles all test suites, and the tests within each test suite, 
   // making sure that death tests are still run first.
   void ShuffleTests();
 
-  // Restores the test suites and tests to their order before the first shuffle.
+  // Restores the test suites and tests to their order before the first shuffle. 
   void UnshuffleTests();
 
   // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
@@ -875,37 +875,37 @@ class GTEST_API_ UnitTestImpl {
   // before/after the tests are run.
   std::vector<Environment*> environments_;
 
-  // The vector of TestSuites in their original order.  It owns the
+  // The vector of TestSuites in their original order.  It owns the 
   // elements in the vector.
-  std::vector<TestSuite*> test_suites_;
+  std::vector<TestSuite*> test_suites_; 
 
-  // Provides a level of indirection for the test suite list to allow
-  // easy shuffling and restoring the test suite order.  The i-th
-  // element of this vector is the index of the i-th test suite in the
+  // Provides a level of indirection for the test suite list to allow 
+  // easy shuffling and restoring the test suite order.  The i-th 
+  // element of this vector is the index of the i-th test suite in the 
   // shuffled order.
-  std::vector<int> test_suite_indices_;
+  std::vector<int> test_suite_indices_; 
 
   // ParameterizedTestRegistry object used to register value-parameterized
   // tests.
-  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
-  internal::TypeParameterizedTestSuiteRegistry
-      type_parameterized_test_registry_;
-
-  // The set holding the name of parameterized
-  // test suites that may go uninstantiated.
-  std::set<std::string> ignored_parameterized_test_suites_;
-
+  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_; 
+  internal::TypeParameterizedTestSuiteRegistry 
+      type_parameterized_test_registry_; 
+
+  // The set holding the name of parameterized 
+  // test suites that may go uninstantiated. 
+  std::set<std::string> ignored_parameterized_test_suites_; 
+ 
   // Indicates whether RegisterParameterizedTests() has been called already.
   bool parameterized_tests_registered_;
 
-  // Index of the last death test suite registered.  Initially -1.
-  int last_death_test_suite_;
+  // Index of the last death test suite registered.  Initially -1. 
+  int last_death_test_suite_; 
 
-  // This points to the TestSuite for the currently running test.  It
-  // changes as Google Test goes through one test suite after another.
+  // This points to the TestSuite for the currently running test.  It 
+  // changes as Google Test goes through one test suite after another. 
   // When no test is running, this is set to NULL and Google Test
   // stores assertion results in ad_hoc_test_result_.  Initially NULL.
-  TestSuite* current_test_suite_;
+  TestSuite* current_test_suite_; 
 
   // This points to the TestInfo for the currently running test.  It
   // changes as Google Test goes through one test after another.  When
@@ -933,7 +933,7 @@ class GTEST_API_ UnitTestImpl {
   // desired.
   OsStackTraceGetterInterface* os_stack_trace_getter_;
 
-  // True if and only if PostFlagParsingInit() has been called.
+  // True if and only if PostFlagParsingInit() has been called. 
   bool post_flag_parse_init_performed_;
 
   // The random number seed used at the beginning of the test run.
@@ -952,8 +952,8 @@ class GTEST_API_ UnitTestImpl {
 #if GTEST_HAS_DEATH_TEST
   // The decomposed components of the gtest_internal_run_death_test flag,
   // parsed when RUN_ALL_TESTS is called.
-  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
-  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
+  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; 
+  std::unique_ptr<internal::DeathTestFactory> death_test_factory_; 
 #endif  // GTEST_HAS_DEATH_TEST
 
   // A per-thread stack of traces created by the SCOPED_TRACE() macro.
@@ -1020,9 +1020,9 @@ bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
   char* end;
   // BiggestConvertible is the largest integer type that system-provided
   // string-to-number conversion routines can return.
-  using BiggestConvertible = unsigned long long;  // NOLINT
+  using BiggestConvertible = unsigned long long;  // NOLINT 
 
-  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT 
   const bool parse_success = *end == '\0' && errno == 0;
 
   GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
@@ -1063,7 +1063,7 @@ class TestResultAccessor {
 #if GTEST_CAN_STREAM_RESULTS_
 
 // Streams test results to the given port on the given host machine.
-class StreamingListener : public EmptyTestEventListener {
+class StreamingListener : public EmptyTestEventListener { 
  public:
   // Abstract base class for writing strings to a socket.
   class AbstractSocketWriter {
@@ -1071,35 +1071,35 @@ class StreamingListener : public EmptyTestEventListener {
     virtual ~AbstractSocketWriter() {}
 
     // Sends a string to the socket.
-    virtual void Send(const std::string& message) = 0;
+    virtual void Send(const std::string& message) = 0; 
 
     // Closes the socket.
     virtual void CloseConnection() {}
 
     // Sends a string and a newline to the socket.
-    void SendLn(const std::string& message) { Send(message + "\n"); }
+    void SendLn(const std::string& message) { Send(message + "\n"); } 
   };
 
   // Concrete class for actually writing strings to a socket.
   class SocketWriter : public AbstractSocketWriter {
    public:
-    SocketWriter(const std::string& host, const std::string& port)
+    SocketWriter(const std::string& host, const std::string& port) 
         : sockfd_(-1), host_name_(host), port_num_(port) {
       MakeConnection();
     }
 
-    ~SocketWriter() override {
+    ~SocketWriter() override { 
       if (sockfd_ != -1)
         CloseConnection();
     }
 
     // Sends a string to the socket.
-    void Send(const std::string& message) override {
+    void Send(const std::string& message) override { 
       GTEST_CHECK_(sockfd_ != -1)
           << "Send() can be called only when there is a connection.";
 
-      const auto len = static_cast<size_t>(message.length());
-      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
+      const auto len = static_cast<size_t>(message.length()); 
+      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) { 
         GTEST_LOG_(WARNING)
             << "stream_result_to: failed to stream to "
             << host_name_ << ":" << port_num_;
@@ -1111,7 +1111,7 @@ class StreamingListener : public EmptyTestEventListener {
     void MakeConnection();
 
     // Closes the socket.
-    void CloseConnection() override {
+    void CloseConnection() override { 
       GTEST_CHECK_(sockfd_ != -1)
           << "CloseConnection() can be called only when there is a connection.";
 
@@ -1120,28 +1120,28 @@ class StreamingListener : public EmptyTestEventListener {
     }
 
     int sockfd_;  // socket file descriptor
-    const std::string host_name_;
-    const std::string port_num_;
+    const std::string host_name_; 
+    const std::string port_num_; 
 
     GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
   };  // class SocketWriter
 
   // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
-  static std::string UrlEncode(const char* str);
+  static std::string UrlEncode(const char* str); 
 
-  StreamingListener(const std::string& host, const std::string& port)
-      : socket_writer_(new SocketWriter(host, port)) {
-    Start();
-  }
+  StreamingListener(const std::string& host, const std::string& port) 
+      : socket_writer_(new SocketWriter(host, port)) { 
+    Start(); 
+  } 
 
   explicit StreamingListener(AbstractSocketWriter* socket_writer)
       : socket_writer_(socket_writer) { Start(); }
 
-  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
+  void OnTestProgramStart(const UnitTest& /* unit_test */) override { 
     SendLn("event=TestProgramStart");
   }
 
-  void OnTestProgramEnd(const UnitTest& unit_test) override {
+  void OnTestProgramEnd(const UnitTest& unit_test) override { 
     // Note that Google Test current only report elapsed time for each
     // test iteration, not for the entire test program.
     SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
@@ -1150,47 +1150,47 @@ class StreamingListener : public EmptyTestEventListener {
     socket_writer_->CloseConnection();
   }
 
-  void OnTestIterationStart(const UnitTest& /* unit_test */,
-                            int iteration) override {
+  void OnTestIterationStart(const UnitTest& /* unit_test */, 
+                            int iteration) override { 
     SendLn("event=TestIterationStart&iteration=" +
            StreamableToString(iteration));
   }
 
-  void OnTestIterationEnd(const UnitTest& unit_test,
-                          int /* iteration */) override {
+  void OnTestIterationEnd(const UnitTest& unit_test, 
+                          int /* iteration */) override { 
     SendLn("event=TestIterationEnd&passed=" +
            FormatBool(unit_test.Passed()) + "&elapsed_time=" +
            StreamableToString(unit_test.elapsed_time()) + "ms");
   }
 
-  // Note that "event=TestCaseStart" is a wire format and has to remain
-  // "case" for compatibility
-  void OnTestCaseStart(const TestCase& test_case) override {
+  // Note that "event=TestCaseStart" is a wire format and has to remain 
+  // "case" for compatibility 
+  void OnTestCaseStart(const TestCase& test_case) override { 
     SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
   }
 
-  // Note that "event=TestCaseEnd" is a wire format and has to remain
-  // "case" for compatibility
-  void OnTestCaseEnd(const TestCase& test_case) override {
-    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
-           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
-           "ms");
+  // Note that "event=TestCaseEnd" is a wire format and has to remain 
+  // "case" for compatibility 
+  void OnTestCaseEnd(const TestCase& test_case) override { 
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + 
+           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + 
+           "ms"); 
   }
 
-  void OnTestStart(const TestInfo& test_info) override {
+  void OnTestStart(const TestInfo& test_info) override { 
     SendLn(std::string("event=TestStart&name=") + test_info.name());
   }
 
-  void OnTestEnd(const TestInfo& test_info) override {
+  void OnTestEnd(const TestInfo& test_info) override { 
     SendLn("event=TestEnd&passed=" +
            FormatBool((test_info.result())->Passed()) +
            "&elapsed_time=" +
            StreamableToString((test_info.result())->elapsed_time()) + "ms");
   }
 
-  void OnTestPartResult(const TestPartResult& test_part_result) override {
+  void OnTestPartResult(const TestPartResult& test_part_result) override { 
     const char* file_name = test_part_result.file_name();
-    if (file_name == nullptr) file_name = "";
+    if (file_name == nullptr) file_name = ""; 
     SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
            "&line=" + StreamableToString(test_part_result.line_number()) +
            "&message=" + UrlEncode(test_part_result.message()));
@@ -1198,15 +1198,15 @@ class StreamingListener : public EmptyTestEventListener {
 
  private:
   // Sends the given message and a newline to the socket.
-  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }
+  void SendLn(const std::string& message) { socket_writer_->SendLn(message); } 
 
   // Called at the start of streaming to notify the receiver what
   // protocol we are using.
   void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
 
-  std::string FormatBool(bool value) { return value ? "1" : "0"; }
+  std::string FormatBool(bool value) { return value ? "1" : "0"; } 
 
-  const std::unique_ptr<AbstractSocketWriter> socket_writer_;
+  const std::unique_ptr<AbstractSocketWriter> socket_writer_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
 };  // class StreamingListener
@@ -1216,6 +1216,6 @@ class StreamingListener : public EmptyTestEventListener {
 }  // namespace internal
 }  // namespace testing
 
-GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
-
-#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 
+ 
+#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_ 
diff --git a/contrib/restricted/googletest/googletest/src/gtest-matchers.cc b/contrib/restricted/googletest/googletest/src/gtest-matchers.cc
index 65104ebab1..eee2140069 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-matchers.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-matchers.cc
@@ -1,97 +1,97 @@
-// Copyright 2007, 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 file implements just enough of the matcher interface to allow
-// EXPECT_DEATH and friends to accept a matcher argument.
-
-#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-port.h"
-#include "gtest/gtest-matchers.h"
-
-#include <string>
-
-namespace testing {
-
-// Constructs a matcher that matches a const std::string& whose value is
-// equal to s.
-Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a const std::string& whose value is
-// equal to s.
-Matcher<const std::string&>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a std::string whose value is equal to
-// s.
-Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a std::string whose value is equal to
-// s.
-Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
-
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-// Constructs a matcher that matches a const StringView& whose value is
-// equal to s.
-Matcher<const internal::StringView&>::Matcher(const std::string& s) {
-  *this = Eq(s);
-}
-
-// Constructs a matcher that matches a const StringView& whose value is
-// equal to s.
-Matcher<const internal::StringView&>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a const StringView& whose value is
-// equal to s.
-Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a StringView whose value is equal to
-// s.
-Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); }
-
-// Constructs a matcher that matches a StringView whose value is equal to
-// s.
-Matcher<internal::StringView>::Matcher(const char* s) {
-  *this = Eq(std::string(s));
-}
-
-// Constructs a matcher that matches a StringView whose value is equal to
-// s.
-Matcher<internal::StringView>::Matcher(internal::StringView s) {
-  *this = Eq(std::string(s));
-}
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-
-}  // namespace testing
+// Copyright 2007, 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 file implements just enough of the matcher interface to allow 
+// EXPECT_DEATH and friends to accept a matcher argument. 
+ 
+#include "gtest/internal/gtest-internal.h" 
+#include "gtest/internal/gtest-port.h" 
+#include "gtest/gtest-matchers.h" 
+ 
+#include <string> 
+ 
+namespace testing { 
+ 
+// Constructs a matcher that matches a const std::string& whose value is 
+// equal to s. 
+Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } 
+ 
+// Constructs a matcher that matches a const std::string& whose value is 
+// equal to s. 
+Matcher<const std::string&>::Matcher(const char* s) { 
+  *this = Eq(std::string(s)); 
+} 
+ 
+// Constructs a matcher that matches a std::string whose value is equal to 
+// s. 
+Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } 
+ 
+// Constructs a matcher that matches a std::string whose value is equal to 
+// s. 
+Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); } 
+ 
+#if GTEST_INTERNAL_HAS_STRING_VIEW 
+// Constructs a matcher that matches a const StringView& whose value is 
+// equal to s. 
+Matcher<const internal::StringView&>::Matcher(const std::string& s) { 
+  *this = Eq(s); 
+} 
+ 
+// Constructs a matcher that matches a const StringView& whose value is 
+// equal to s. 
+Matcher<const internal::StringView&>::Matcher(const char* s) { 
+  *this = Eq(std::string(s)); 
+} 
+ 
+// Constructs a matcher that matches a const StringView& whose value is 
+// equal to s. 
+Matcher<const internal::StringView&>::Matcher(internal::StringView s) { 
+  *this = Eq(std::string(s)); 
+} 
+ 
+// Constructs a matcher that matches a StringView whose value is equal to 
+// s. 
+Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } 
+ 
+// Constructs a matcher that matches a StringView whose value is equal to 
+// s. 
+Matcher<internal::StringView>::Matcher(const char* s) { 
+  *this = Eq(std::string(s)); 
+} 
+ 
+// Constructs a matcher that matches a StringView whose value is equal to 
+// s. 
+Matcher<internal::StringView>::Matcher(internal::StringView s) { 
+  *this = Eq(std::string(s)); 
+} 
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW 
+ 
+}  // namespace testing 
diff --git a/contrib/restricted/googletest/googletest/src/gtest-port.cc b/contrib/restricted/googletest/googletest/src/gtest-port.cc
index da65822d98..ab86e4ba04 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-port.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-port.cc
@@ -27,25 +27,25 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 #include "gtest/internal/gtest-port.h"
 
 #include <limits.h>
-#include <stdio.h>
+#include <stdio.h> 
 #include <stdlib.h>
 #include <string.h>
-#include <cstdint>
+#include <cstdint> 
 #include <fstream>
-#include <memory>
+#include <memory> 
 
 #if GTEST_OS_WINDOWS
 # include <windows.h>
 # include <io.h>
 # include <sys/stat.h>
 # include <map>  // Used in ThreadLocal.
-# ifdef _MSC_VER
-#  include <crtdbg.h>
-# endif  // _MSC_VER
+# ifdef _MSC_VER 
+#  include <crtdbg.h> 
+# endif  // _MSC_VER 
 #else
 # include <unistd.h>
 #endif  // GTEST_OS_WINDOWS
@@ -56,14 +56,14 @@
 # include <mach/vm_map.h>
 #endif  // GTEST_OS_MAC
 
-#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
-# include <sys/sysctl.h>
-# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
-#  include <sys/user.h>
-# endif
-#endif
-
+#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ 
+    GTEST_OS_NETBSD || GTEST_OS_OPENBSD 
+# include <sys/sysctl.h> 
+# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD 
+#  include <sys/user.h> 
+# endif 
+#endif 
+ 
 #if GTEST_OS_QNX
 # include <devctl.h>
 # include <fcntl.h>
@@ -75,11 +75,11 @@
 # include <sys/types.h>
 #endif  // GTEST_OS_AIX
 
-#if GTEST_OS_FUCHSIA
+#if GTEST_OS_FUCHSIA 
 # error #include <zircon/process.h>
 # error #include <zircon/syscalls.h>
-#endif  // GTEST_OS_FUCHSIA
-
+#endif  // GTEST_OS_FUCHSIA 
+ 
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest-message.h"
 #include "gtest/internal/gtest-internal.h"
@@ -102,7 +102,7 @@ const int kStdErrFileno = STDERR_FILENO;
 
 namespace {
 template <typename T>
-T ReadProcFileField(const std::string& filename, int field) {
+T ReadProcFileField(const std::string& filename, int field) { 
   std::string dummy;
   std::ifstream file(filename.c_str());
   while (field-- > 0) {
@@ -116,9 +116,9 @@ T ReadProcFileField(const std::string& filename, int field) {
 
 // Returns the number of active threads, or 0 when there is an error.
 size_t GetThreadCount() {
-  const std::string filename =
+  const std::string filename = 
       (Message() << "/proc/" << getpid() << "/stat").GetString();
-  return ReadProcFileField<size_t>(filename, 19);
+  return ReadProcFileField<size_t>(filename, 19); 
 }
 
 #elif GTEST_OS_MAC
@@ -140,82 +140,82 @@ size_t GetThreadCount() {
   }
 }
 
-#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
-      GTEST_OS_NETBSD
-
-#if GTEST_OS_NETBSD
-#undef KERN_PROC
-#define KERN_PROC KERN_PROC2
-#define kinfo_proc kinfo_proc2
-#endif
-
-#if GTEST_OS_DRAGONFLY
-#define KP_NLWP(kp) (kp.kp_nthreads)
-#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
-#define KP_NLWP(kp) (kp.ki_numthreads)
-#elif GTEST_OS_NETBSD
-#define KP_NLWP(kp) (kp.p_nlwps)
-#endif
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID,
-    getpid(),
-#if GTEST_OS_NETBSD
-    sizeof(struct kinfo_proc),
-    1,
-#endif
-  };
-  u_int miblen = sizeof(mib) / sizeof(mib[0]);
-  struct kinfo_proc info;
-  size_t size = sizeof(info);
-  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
-    return 0;
-  }
-  return static_cast<size_t>(KP_NLWP(info));
-}
-#elif GTEST_OS_OPENBSD
-
-// Returns the number of threads running in the process, or 0 to indicate that
-// we cannot detect it.
-size_t GetThreadCount() {
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
-    getpid(),
-    sizeof(struct kinfo_proc),
-    0,
-  };
-  u_int miblen = sizeof(mib) / sizeof(mib[0]);
-
-  // get number of structs
-  size_t size;
-  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
-    return 0;
-  }
-
-  mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4]));
-
-  // populate array of structs
-  struct kinfo_proc info[mib[5]];
-  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
-    return 0;
-  }
-
-  // exclude empty members
-  size_t nthreads = 0;
-  for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) {
-    if (info[i].p_tid != -1)
-      nthreads++;
-  }
-  return nthreads;
-}
-
+#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ 
+      GTEST_OS_NETBSD 
+ 
+#if GTEST_OS_NETBSD 
+#undef KERN_PROC 
+#define KERN_PROC KERN_PROC2 
+#define kinfo_proc kinfo_proc2 
+#endif 
+ 
+#if GTEST_OS_DRAGONFLY 
+#define KP_NLWP(kp) (kp.kp_nthreads) 
+#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD 
+#define KP_NLWP(kp) (kp.ki_numthreads) 
+#elif GTEST_OS_NETBSD 
+#define KP_NLWP(kp) (kp.p_nlwps) 
+#endif 
+ 
+// Returns the number of threads running in the process, or 0 to indicate that 
+// we cannot detect it. 
+size_t GetThreadCount() { 
+  int mib[] = { 
+    CTL_KERN, 
+    KERN_PROC, 
+    KERN_PROC_PID, 
+    getpid(), 
+#if GTEST_OS_NETBSD 
+    sizeof(struct kinfo_proc), 
+    1, 
+#endif 
+  }; 
+  u_int miblen = sizeof(mib) / sizeof(mib[0]); 
+  struct kinfo_proc info; 
+  size_t size = sizeof(info); 
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) { 
+    return 0; 
+  } 
+  return static_cast<size_t>(KP_NLWP(info)); 
+} 
+#elif GTEST_OS_OPENBSD 
+ 
+// Returns the number of threads running in the process, or 0 to indicate that 
+// we cannot detect it. 
+size_t GetThreadCount() { 
+  int mib[] = { 
+    CTL_KERN, 
+    KERN_PROC, 
+    KERN_PROC_PID | KERN_PROC_SHOW_THREADS, 
+    getpid(), 
+    sizeof(struct kinfo_proc), 
+    0, 
+  }; 
+  u_int miblen = sizeof(mib) / sizeof(mib[0]); 
+ 
+  // get number of structs 
+  size_t size; 
+  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) { 
+    return 0; 
+  } 
+ 
+  mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4])); 
+ 
+  // populate array of structs 
+  struct kinfo_proc info[mib[5]]; 
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) { 
+    return 0; 
+  } 
+ 
+  // exclude empty members 
+  size_t nthreads = 0; 
+  for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) { 
+    if (info[i].p_tid != -1) 
+      nthreads++; 
+  } 
+  return nthreads; 
+} 
+ 
 #elif GTEST_OS_QNX
 
 // Returns the number of threads running in the process, or 0 to indicate that
@@ -227,7 +227,7 @@ size_t GetThreadCount() {
   }
   procfs_info process_info;
   const int status =
-      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr);
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr); 
   close(fd);
   if (status == EOK) {
     return static_cast<size_t>(process_info.num_threads);
@@ -241,7 +241,7 @@ size_t GetThreadCount() {
 size_t GetThreadCount() {
   struct procentry64 entry;
   pid_t pid = getpid();
-  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
+  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1); 
   if (status == 1) {
     return entry.pi_thcount;
   } else {
@@ -249,25 +249,25 @@ size_t GetThreadCount() {
   }
 }
 
-#elif GTEST_OS_FUCHSIA
-
-size_t GetThreadCount() {
-  int dummy_buffer;
-  size_t avail;
-  zx_status_t status = zx_object_get_info(
-      zx_process_self(),
-      ZX_INFO_PROCESS_THREADS,
-      &dummy_buffer,
-      0,
-      nullptr,
-      &avail);
-  if (status == ZX_OK) {
-    return avail;
-  } else {
-    return 0;
-  }
-}
-
+#elif GTEST_OS_FUCHSIA 
+ 
+size_t GetThreadCount() { 
+  int dummy_buffer; 
+  size_t avail; 
+  zx_status_t status = zx_object_get_info( 
+      zx_process_self(), 
+      ZX_INFO_PROCESS_THREADS, 
+      &dummy_buffer, 
+      0, 
+      nullptr, 
+      &avail); 
+  if (status == ZX_OK) { 
+    return avail; 
+  } else { 
+    return 0; 
+  } 
+} 
+ 
 #else
 
 size_t GetThreadCount() {
@@ -281,7 +281,7 @@ size_t GetThreadCount() {
 #if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
 
 void SleepMilliseconds(int n) {
-  ::Sleep(static_cast<DWORD>(n));
+  ::Sleep(static_cast<DWORD>(n)); 
 }
 
 AutoHandle::AutoHandle()
@@ -319,15 +319,15 @@ void AutoHandle::Reset(HANDLE handle) {
 bool AutoHandle::IsCloseable() const {
   // Different Windows APIs may use either of these values to represent an
   // invalid handle.
-  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
+  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE; 
 }
 
 Notification::Notification()
-    : event_(::CreateEvent(nullptr,     // Default security attributes.
-                           TRUE,        // Do not reset automatically.
-                           FALSE,       // Initially unset.
-                           nullptr)) {  // Anonymous event.
-  GTEST_CHECK_(event_.Get() != nullptr);
+    : event_(::CreateEvent(nullptr,     // Default security attributes. 
+                           TRUE,        // Do not reset automatically. 
+                           FALSE,       // Initially unset. 
+                           nullptr)) {  // Anonymous event. 
+  GTEST_CHECK_(event_.Get() != nullptr); 
 }
 
 void Notification::Notify() {
@@ -353,7 +353,7 @@ Mutex::~Mutex() {
   if (type_ == kDynamic) {
     ::DeleteCriticalSection(critical_section_);
     delete critical_section_;
-    critical_section_ = nullptr;
+    critical_section_ = nullptr; 
   }
 }
 
@@ -380,41 +380,41 @@ void Mutex::AssertHeld() {
       << "The current thread is not holding the mutex @" << this;
 }
 
-namespace {
-
-#ifdef _MSC_VER
-// Use the RAII idiom to flag mem allocs that are intentionally never
-// deallocated. The motivation is to silence the false positive mem leaks
-// that are reported by the debug version of MS's CRT which can only detect
-// if an alloc is missing a matching deallocation.
-// Example:
-//    MemoryIsNotDeallocated memory_is_not_deallocated;
-//    critical_section_ = new CRITICAL_SECTION;
-//
-class MemoryIsNotDeallocated
-{
- public:
-  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
-    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
-    // doesn't report mem leak if there's no matching deallocation.
-    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
-  }
-
-  ~MemoryIsNotDeallocated() {
-    // Restore the original _CRTDBG_ALLOC_MEM_DF flag
-    _CrtSetDbgFlag(old_crtdbg_flag_);
-  }
-
- private:
-  int old_crtdbg_flag_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
-};
-#endif  // _MSC_VER
-
-}  // namespace
-
+namespace { 
+ 
+#ifdef _MSC_VER 
+// Use the RAII idiom to flag mem allocs that are intentionally never 
+// deallocated. The motivation is to silence the false positive mem leaks 
+// that are reported by the debug version of MS's CRT which can only detect 
+// if an alloc is missing a matching deallocation. 
+// Example: 
+//    MemoryIsNotDeallocated memory_is_not_deallocated; 
+//    critical_section_ = new CRITICAL_SECTION; 
+// 
+class MemoryIsNotDeallocated 
+{ 
+ public: 
+  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) { 
+    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); 
+    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT 
+    // doesn't report mem leak if there's no matching deallocation. 
+    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF); 
+  } 
+ 
+  ~MemoryIsNotDeallocated() { 
+    // Restore the original _CRTDBG_ALLOC_MEM_DF flag 
+    _CrtSetDbgFlag(old_crtdbg_flag_); 
+  } 
+ 
+ private: 
+  int old_crtdbg_flag_; 
+ 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated); 
+}; 
+#endif  // _MSC_VER 
+ 
+}  // namespace 
+ 
 // Initializes owner_thread_id_ and critical_section_ in static mutexes.
 void Mutex::ThreadSafeLazyInit() {
   // Dynamic mutexes are initialized in the constructor.
@@ -425,13 +425,13 @@ void Mutex::ThreadSafeLazyInit() {
         // If critical_section_init_phase_ was 0 before the exchange, we
         // are the first to test it and need to perform the initialization.
         owner_thread_id_ = 0;
-        {
-          // Use RAII to flag that following mem alloc is never deallocated.
-#ifdef _MSC_VER
-          MemoryIsNotDeallocated memory_is_not_deallocated;
-#endif  // _MSC_VER
-          critical_section_ = new CRITICAL_SECTION;
-        }
+        { 
+          // Use RAII to flag that following mem alloc is never deallocated. 
+#ifdef _MSC_VER 
+          MemoryIsNotDeallocated memory_is_not_deallocated; 
+#endif  // _MSC_VER 
+          critical_section_ = new CRITICAL_SECTION; 
+        } 
         ::InitializeCriticalSection(critical_section_);
         // Updates the critical_section_init_phase_ to 2 to signal
         // initialization complete.
@@ -471,15 +471,15 @@ class ThreadWithParamSupport : public ThreadWithParamBase {
     ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
     DWORD thread_id;
     HANDLE thread_handle = ::CreateThread(
-        nullptr,  // Default security.
-        0,        // Default stack size.
+        nullptr,  // Default security. 
+        0,        // Default stack size. 
         &ThreadWithParamSupport::ThreadMain,
-        param,        // Parameter to ThreadMainStatic
-        0x0,          // Default creation flags.
+        param,        // Parameter to ThreadMainStatic 
+        0x0,          // Default creation flags. 
         &thread_id);  // Need a valid pointer for the call to work under Win98.
-    GTEST_CHECK_(thread_handle != nullptr)
-        << "CreateThread failed with error " << ::GetLastError() << ".";
-    if (thread_handle == nullptr) {
+    GTEST_CHECK_(thread_handle != nullptr) 
+        << "CreateThread failed with error " << ::GetLastError() << "."; 
+    if (thread_handle == nullptr) { 
       delete param;
     }
     return thread_handle;
@@ -491,15 +491,15 @@ class ThreadWithParamSupport : public ThreadWithParamBase {
         : runnable_(runnable),
           thread_can_start_(thread_can_start) {
     }
-    std::unique_ptr<Runnable> runnable_;
+    std::unique_ptr<Runnable> runnable_; 
     // Does not own.
     Notification* thread_can_start_;
   };
 
   static DWORD WINAPI ThreadMain(void* ptr) {
     // Transfers ownership.
-    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
-    if (param->thread_can_start_ != nullptr)
+    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr)); 
+    if (param->thread_can_start_ != nullptr) 
       param->thread_can_start_->WaitForNotification();
     param->runnable_->Run();
     return 0;
@@ -538,9 +538,9 @@ class ThreadLocalRegistryImpl {
   // Returns a value that can be used to identify the thread from other threads.
   static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
       const ThreadLocalBase* thread_local_instance) {
-#ifdef _MSC_VER
-    MemoryIsNotDeallocated memory_is_not_deallocated;
-#endif  // _MSC_VER
+#ifdef _MSC_VER 
+    MemoryIsNotDeallocated memory_is_not_deallocated; 
+#endif  // _MSC_VER 
     DWORD current_thread = ::GetCurrentThreadId();
     MutexLock lock(&mutex_);
     ThreadIdToThreadLocals* const thread_to_thread_locals =
@@ -560,7 +560,7 @@ class ThreadLocalRegistryImpl {
           thread_local_values
               .insert(std::make_pair(
                   thread_local_instance,
-                  std::shared_ptr<ThreadLocalValueHolderBase>(
+                  std::shared_ptr<ThreadLocalValueHolderBase>( 
                       thread_local_instance->NewValueForCurrentThread())))
               .first;
     }
@@ -569,7 +569,7 @@ class ThreadLocalRegistryImpl {
 
   static void OnThreadLocalDestroyed(
       const ThreadLocalBase* thread_local_instance) {
-    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders; 
     // Clean up the ThreadLocalValues data structure while holding the lock, but
     // defer the destruction of the ThreadLocalValueHolderBases.
     {
@@ -597,7 +597,7 @@ class ThreadLocalRegistryImpl {
 
   static void OnThreadExit(DWORD thread_id) {
     GTEST_CHECK_(thread_id != 0) << ::GetLastError();
-    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders; 
     // Clean up the ThreadIdToThreadLocals data structure while holding the
     // lock, but defer the destruction of the ThreadLocalValueHolderBases.
     {
@@ -624,8 +624,8 @@ class ThreadLocalRegistryImpl {
  private:
   // In a particular thread, maps a ThreadLocal object to its value.
   typedef std::map<const ThreadLocalBase*,
-                   std::shared_ptr<ThreadLocalValueHolderBase> >
-      ThreadLocalValues;
+                   std::shared_ptr<ThreadLocalValueHolderBase> > 
+      ThreadLocalValues; 
   // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
   // thread's ID.
   typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
@@ -640,17 +640,17 @@ class ThreadLocalRegistryImpl {
     HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
                                  FALSE,
                                  thread_id);
-    GTEST_CHECK_(thread != nullptr);
-    // We need to pass a valid thread ID pointer into CreateThread for it
+    GTEST_CHECK_(thread != nullptr); 
+    // We need to pass a valid thread ID pointer into CreateThread for it 
     // to work correctly under Win98.
     DWORD watcher_thread_id;
     HANDLE watcher_thread = ::CreateThread(
-        nullptr,  // Default security.
-        0,        // Default stack size
+        nullptr,  // Default security. 
+        0,        // Default stack size 
         &ThreadLocalRegistryImpl::WatcherThreadFunc,
         reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
-        CREATE_SUSPENDED, &watcher_thread_id);
-    GTEST_CHECK_(watcher_thread != nullptr);
+        CREATE_SUSPENDED, &watcher_thread_id); 
+    GTEST_CHECK_(watcher_thread != nullptr); 
     // Give the watcher thread the same priority as ours to avoid being
     // blocked by it.
     ::SetThreadPriority(watcher_thread,
@@ -675,10 +675,10 @@ class ThreadLocalRegistryImpl {
   // Returns map of thread local instances.
   static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
     mutex_.AssertHeld();
-#ifdef _MSC_VER
-    MemoryIsNotDeallocated memory_is_not_deallocated;
-#endif  // _MSC_VER
-    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
+#ifdef _MSC_VER 
+    MemoryIsNotDeallocated memory_is_not_deallocated; 
+#endif  // _MSC_VER 
+    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals(); 
     return map;
   }
 
@@ -688,8 +688,8 @@ class ThreadLocalRegistryImpl {
   static Mutex thread_map_mutex_;
 };
 
-Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);  // NOLINT
-Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);  // NOLINT
+Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);  // NOLINT 
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);  // NOLINT 
 
 ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
       const ThreadLocalBase* thread_local_instance) {
@@ -720,7 +720,7 @@ RE::~RE() {
   free(const_cast<char*>(pattern_));
 }
 
-// Returns true if and only if regular expression re matches the entire str.
+// Returns true if and only if regular expression re matches the entire str. 
 bool RE::FullMatch(const char* str, const RE& re) {
   if (!re.is_valid_) return false;
 
@@ -728,8 +728,8 @@ bool RE::FullMatch(const char* str, const RE& re) {
   return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
 }
 
-// Returns true if and only if regular expression re matches a substring of
-// str (including str itself).
+// Returns true if and only if regular expression re matches a substring of 
+// str (including str itself). 
 bool RE::PartialMatch(const char* str, const RE& re) {
   if (!re.is_valid_) return false;
 
@@ -769,14 +769,14 @@ void RE::Init(const char* regex) {
 
 #elif GTEST_USES_SIMPLE_RE
 
-// Returns true if and only if ch appears anywhere in str (excluding the
+// Returns true if and only if ch appears anywhere in str (excluding the 
 // terminating '\0' character).
 bool IsInSet(char ch, const char* str) {
-  return ch != '\0' && strchr(str, ch) != nullptr;
+  return ch != '\0' && strchr(str, ch) != nullptr; 
 }
 
-// Returns true if and only if ch belongs to the given classification.
-// Unlike similar functions in <ctype.h>, these aren't affected by the
+// Returns true if and only if ch belongs to the given classification. 
+// Unlike similar functions in <ctype.h>, these aren't affected by the 
 // current locale.
 bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
 bool IsAsciiPunct(char ch) {
@@ -789,13 +789,13 @@ bool IsAsciiWordChar(char ch) {
       ('0' <= ch && ch <= '9') || ch == '_';
 }
 
-// Returns true if and only if "\\c" is a supported escape sequence.
+// Returns true if and only if "\\c" is a supported escape sequence. 
 bool IsValidEscape(char c) {
   return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
 }
 
-// Returns true if and only if the given atom (specified by escaped and
-// pattern) matches ch.  The result is undefined if the atom is invalid.
+// Returns true if and only if the given atom (specified by escaped and 
+// pattern) matches ch.  The result is undefined if the atom is invalid. 
 bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
   if (escaped) {  // "\\p" where p is pattern_char.
     switch (pattern_char) {
@@ -818,7 +818,7 @@ bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
 }
 
 // Helper function used by ValidateRegex() to format error messages.
-static std::string FormatRegexSyntaxError(const char* regex, int index) {
+static std::string FormatRegexSyntaxError(const char* regex, int index) { 
   return (Message() << "Syntax error at index " << index
           << " in simple regular expression \"" << regex << "\": ").GetString();
 }
@@ -826,14 +826,14 @@ static std::string FormatRegexSyntaxError(const char* regex, int index) {
 // Generates non-fatal failures and returns false if regex is invalid;
 // otherwise returns true.
 bool ValidateRegex(const char* regex) {
-  if (regex == nullptr) {
+  if (regex == nullptr) { 
     ADD_FAILURE() << "NULL is not a valid simple regular expression.";
     return false;
   }
 
   bool is_valid = true;
 
-  // True if and only if ?, *, or + can follow the previous atom.
+  // True if and only if ?, *, or + can follow the previous atom. 
   bool prev_repeatable = false;
   for (int i = 0; regex[i]; i++) {
     if (regex[i] == '\\') {  // An escape sequence
@@ -909,8 +909,8 @@ bool MatchRepetitionAndRegexAtHead(
   return false;
 }
 
-// Returns true if and only if regex matches a prefix of str. regex must
-// be a valid simple regular expression and not start with "^", or the
+// Returns true if and only if regex matches a prefix of str. regex must 
+// be a valid simple regular expression and not start with "^", or the 
 // result is undefined.
 bool MatchRegexAtHead(const char* regex, const char* str) {
   if (*regex == '\0')  // An empty regex matches a prefix of anything.
@@ -940,8 +940,8 @@ bool MatchRegexAtHead(const char* regex, const char* str) {
   }
 }
 
-// Returns true if and only if regex matches any substring of str.  regex must
-// be a valid simple regular expression, or the result is undefined.
+// Returns true if and only if regex matches any substring of str.  regex must 
+// be a valid simple regular expression, or the result is undefined. 
 //
 // The algorithm is recursive, but the recursion depth doesn't exceed
 // the regex length, so we won't need to worry about running out of
@@ -949,7 +949,7 @@ bool MatchRegexAtHead(const char* regex, const char* str) {
 // exponential with respect to the regex length + the string length,
 // but usually it's must faster (often close to linear).
 bool MatchRegexAnywhere(const char* regex, const char* str) {
-  if (regex == nullptr || str == nullptr) return false;
+  if (regex == nullptr || str == nullptr) return false; 
 
   if (*regex == '^')
     return MatchRegexAtHead(regex + 1, str);
@@ -969,21 +969,21 @@ RE::~RE() {
   free(const_cast<char*>(full_pattern_));
 }
 
-// Returns true if and only if regular expression re matches the entire str.
+// Returns true if and only if regular expression re matches the entire str. 
 bool RE::FullMatch(const char* str, const RE& re) {
   return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
 }
 
-// Returns true if and only if regular expression re matches a substring of
-// str (including str itself).
+// Returns true if and only if regular expression re matches a substring of 
+// str (including str itself). 
 bool RE::PartialMatch(const char* str, const RE& re) {
   return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
 }
 
 // Initializes an RE from its string representation.
 void RE::Init(const char* regex) {
-  pattern_ = full_pattern_ = nullptr;
-  if (regex != nullptr) {
+  pattern_ = full_pattern_ = nullptr; 
+  if (regex != nullptr) { 
     pattern_ = posix::StrDup(regex);
   }
 
@@ -1021,7 +1021,7 @@ const char kUnknownFile[] = "unknown file";
 // Formats a source file path and a line number as they would appear
 // in an error message from the compiler used to compile this code.
 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
-  const std::string file_name(file == nullptr ? kUnknownFile : file);
+  const std::string file_name(file == nullptr ? kUnknownFile : file); 
 
   if (line < 0) {
     return file_name + ":";
@@ -1040,7 +1040,7 @@ GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
 // to the file location it produces, unlike FormatFileLocation().
 GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
     const char* file, int line) {
-  const std::string file_name(file == nullptr ? kUnknownFile : file);
+  const std::string file_name(file == nullptr ? kUnknownFile : file); 
 
   if (line < 0)
     return file_name;
@@ -1066,10 +1066,10 @@ GTestLog::~GTestLog() {
     posix::Abort();
   }
 }
-
+ 
 // Disable Microsoft deprecation warnings for POSIX functions called from
 // this class (creat, dup, dup2, and close)
-GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_() 
 
 #if GTEST_HAS_STREAM_REDIRECTION
 
@@ -1095,9 +1095,9 @@ class CapturedStream {
     filename_ = temp_file_path;
 # else
     // There's no guarantee that a test has write access to the current
-    // directory, so we create the temporary file in a temporary directory.
-    std::string name_template;
-
+    // directory, so we create the temporary file in a temporary directory. 
+    std::string name_template; 
+ 
 #  if GTEST_OS_LINUX_ANDROID
     // Note: Android applications are expected to call the framework's
     // Context.getExternalStorageDirectory() method through JNI to get
@@ -1107,51 +1107,51 @@ class CapturedStream {
     // code as part of a regular standalone executable, which doesn't
     // run in a Dalvik process (e.g. when running it through 'adb shell').
     //
-    // The location /data/local/tmp is directly accessible from native code.
-    // '/sdcard' and other variants cannot be relied on, as they are not
-    // guaranteed to be mounted, or may have a delay in mounting.
-    name_template = "/data/local/tmp/";
-#  elif GTEST_OS_IOS
-    char user_temp_dir[PATH_MAX + 1];
-
-    // Documented alternative to NSTemporaryDirectory() (for obtaining creating
-    // a temporary directory) at
-    // https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/RaceConditions.html#//apple_ref/doc/uid/TP40002585-SW10
-    //
-    // _CS_DARWIN_USER_TEMP_DIR (as well as _CS_DARWIN_USER_CACHE_DIR) is not
-    // documented in the confstr() man page at
-    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/confstr.3.html#//apple_ref/doc/man/3/confstr
-    // but are still available, according to the WebKit patches at
-    // https://trac.webkit.org/changeset/262004/webkit
-    // https://trac.webkit.org/changeset/263705/webkit
-    //
-    // The confstr() implementation falls back to getenv("TMPDIR"). See
-    // https://opensource.apple.com/source/Libc/Libc-1439.100.3/gen/confstr.c.auto.html
-    ::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));
-
-    name_template = user_temp_dir;
-    if (name_template.back() != GTEST_PATH_SEP_[0])
-      name_template.push_back(GTEST_PATH_SEP_[0]);
+    // The location /data/local/tmp is directly accessible from native code. 
+    // '/sdcard' and other variants cannot be relied on, as they are not 
+    // guaranteed to be mounted, or may have a delay in mounting. 
+    name_template = "/data/local/tmp/"; 
+#  elif GTEST_OS_IOS 
+    char user_temp_dir[PATH_MAX + 1]; 
+ 
+    // Documented alternative to NSTemporaryDirectory() (for obtaining creating 
+    // a temporary directory) at 
+    // https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/RaceConditions.html#//apple_ref/doc/uid/TP40002585-SW10 
+    // 
+    // _CS_DARWIN_USER_TEMP_DIR (as well as _CS_DARWIN_USER_CACHE_DIR) is not 
+    // documented in the confstr() man page at 
+    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/confstr.3.html#//apple_ref/doc/man/3/confstr 
+    // but are still available, according to the WebKit patches at 
+    // https://trac.webkit.org/changeset/262004/webkit 
+    // https://trac.webkit.org/changeset/263705/webkit 
+    // 
+    // The confstr() implementation falls back to getenv("TMPDIR"). See 
+    // https://opensource.apple.com/source/Libc/Libc-1439.100.3/gen/confstr.c.auto.html 
+    ::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir)); 
+ 
+    name_template = user_temp_dir; 
+    if (name_template.back() != GTEST_PATH_SEP_[0]) 
+      name_template.push_back(GTEST_PATH_SEP_[0]); 
 #  else
-    name_template = "/tmp/";
-#  endif
-    name_template.append("gtest_captured_stream.XXXXXX");
-
-    // mkstemp() modifies the string bytes in place, and does not go beyond the
-    // string's length. This results in well-defined behavior in C++17.
-    //
-    // The const_cast is needed below C++17. The constraints on std::string
-    // implementations in C++11 and above make assumption behind the const_cast
-    // fairly safe.
-    const int captured_fd = ::mkstemp(const_cast<char*>(name_template.data()));
-    if (captured_fd == -1) {
-      GTEST_LOG_(WARNING)
-          << "Failed to create tmp file " << name_template
-          << " for test; does the test have access to the /tmp directory?";
-    }
-    filename_ = std::move(name_template);
+    name_template = "/tmp/"; 
+#  endif 
+    name_template.append("gtest_captured_stream.XXXXXX"); 
+ 
+    // mkstemp() modifies the string bytes in place, and does not go beyond the 
+    // string's length. This results in well-defined behavior in C++17. 
+    // 
+    // The const_cast is needed below C++17. The constraints on std::string 
+    // implementations in C++11 and above make assumption behind the const_cast 
+    // fairly safe. 
+    const int captured_fd = ::mkstemp(const_cast<char*>(name_template.data())); 
+    if (captured_fd == -1) { 
+      GTEST_LOG_(WARNING) 
+          << "Failed to create tmp file " << name_template 
+          << " for test; does the test have access to the /tmp directory?"; 
+    } 
+    filename_ = std::move(name_template); 
 # endif  // GTEST_OS_WINDOWS
-    fflush(nullptr);
+    fflush(nullptr); 
     dup2(captured_fd, fd_);
     close(captured_fd);
   }
@@ -1163,17 +1163,17 @@ class CapturedStream {
   std::string GetCapturedString() {
     if (uncaptured_fd_ != -1) {
       // Restores the original stream.
-      fflush(nullptr);
+      fflush(nullptr); 
       dup2(uncaptured_fd_, fd_);
       close(uncaptured_fd_);
       uncaptured_fd_ = -1;
     }
 
     FILE* const file = posix::FOpen(filename_.c_str(), "r");
-    if (file == nullptr) {
-      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
-                        << " for capturing stream.";
-    }
+    if (file == nullptr) { 
+      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_ 
+                        << " for capturing stream."; 
+    } 
     const std::string content = ReadEntireFile(file);
     posix::FClose(file);
     return content;
@@ -1188,15 +1188,15 @@ class CapturedStream {
   GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
 };
 
-GTEST_DISABLE_MSC_DEPRECATED_POP_()
+GTEST_DISABLE_MSC_DEPRECATED_POP_() 
 
-static CapturedStream* g_captured_stderr = nullptr;
-static CapturedStream* g_captured_stdout = nullptr;
+static CapturedStream* g_captured_stderr = nullptr; 
+static CapturedStream* g_captured_stdout = nullptr; 
 
 // Starts capturing an output stream (stdout/stderr).
-static void CaptureStream(int fd, const char* stream_name,
-                          CapturedStream** stream) {
-  if (*stream != nullptr) {
+static void CaptureStream(int fd, const char* stream_name, 
+                          CapturedStream** stream) { 
+  if (*stream != nullptr) { 
     GTEST_LOG_(FATAL) << "Only one " << stream_name
                       << " capturer can exist at a time.";
   }
@@ -1204,11 +1204,11 @@ static void CaptureStream(int fd, const char* stream_name,
 }
 
 // Stops capturing the output stream and returns the captured string.
-static std::string GetCapturedStream(CapturedStream** captured_stream) {
+static std::string GetCapturedStream(CapturedStream** captured_stream) { 
   const std::string content = (*captured_stream)->GetCapturedString();
 
   delete *captured_stream;
-  *captured_stream = nullptr;
+  *captured_stream = nullptr; 
 
   return content;
 }
@@ -1236,9 +1236,9 @@ std::string GetCapturedStderr() {
 #endif  // GTEST_HAS_STREAM_REDIRECTION
 
 
-
-
-
+ 
+ 
+ 
 size_t GetFileSize(FILE* file) {
   fseek(file, 0, SEEK_END);
   return static_cast<size_t>(ftell(file));
@@ -1267,30 +1267,30 @@ std::string ReadEntireFile(FILE* file) {
 }
 
 #if GTEST_HAS_DEATH_TEST
-static const std::vector<std::string>* g_injected_test_argvs =
-    nullptr;  // Owned.
+static const std::vector<std::string>* g_injected_test_argvs = 
+    nullptr;  // Owned. 
 
-std::vector<std::string> GetInjectableArgvs() {
-  if (g_injected_test_argvs != nullptr) {
+std::vector<std::string> GetInjectableArgvs() { 
+  if (g_injected_test_argvs != nullptr) { 
     return *g_injected_test_argvs;
   }
   return GetArgvs();
 }
-
-void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
-  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs;
-  g_injected_test_argvs = new_argvs;
-}
-
-void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
-  SetInjectableArgvs(
-      new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
-}
-
-void ClearInjectableArgvs() {
-  delete g_injected_test_argvs;
-  g_injected_test_argvs = nullptr;
-}
+ 
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs) { 
+  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs; 
+  g_injected_test_argvs = new_argvs; 
+} 
+ 
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs) { 
+  SetInjectableArgvs( 
+      new std::vector<std::string>(new_argvs.begin(), new_argvs.end())); 
+} 
+ 
+void ClearInjectableArgvs() { 
+  delete g_injected_test_argvs; 
+  g_injected_test_argvs = nullptr; 
+} 
 #endif  // GTEST_HAS_DEATH_TEST
 
 #if GTEST_OS_WINDOWS_MOBILE
@@ -1320,9 +1320,9 @@ static std::string FlagToEnvVar(const char* flag) {
 // Parses 'str' for a 32-bit signed integer.  If successful, writes
 // the result to *value and returns true; otherwise leaves *value
 // unchanged and returns false.
-bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
+bool ParseInt32(const Message& src_text, const char* str, int32_t* value) { 
   // Parses the environment variable as a decimal integer.
-  char* end = nullptr;
+  char* end = nullptr; 
   const long long_value = strtol(str, &end, 10);  // NOLINT
 
   // Has strtol() consumed all characters in the string?
@@ -1337,13 +1337,13 @@ bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
     return false;
   }
 
-  // Is the parsed value in the range of an int32_t?
-  const auto result = static_cast<int32_t>(long_value);
+  // Is the parsed value in the range of an int32_t? 
+  const auto result = static_cast<int32_t>(long_value); 
   if (long_value == LONG_MAX || long_value == LONG_MIN ||
       // The parsed value overflows as a long.  (strtol() returns
       // LONG_MAX or LONG_MIN when the input overflows.)
       result != long_value
-      // The parsed value overflows as an int32_t.
+      // The parsed value overflows as an int32_t. 
       ) {
     Message msg;
     msg << "WARNING: " << src_text
@@ -1361,33 +1361,33 @@ bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
 // Reads and returns the Boolean environment variable corresponding to
 // the given flag; if it's not set, returns default_value.
 //
-// The value is considered true if and only if it's not "0".
+// The value is considered true if and only if it's not "0". 
 bool BoolFromGTestEnv(const char* flag, bool default_value) {
 #if defined(GTEST_GET_BOOL_FROM_ENV_)
   return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
-#else
+#else 
   const std::string env_var = FlagToEnvVar(flag);
   const char* const string_value = posix::GetEnv(env_var.c_str());
-  return string_value == nullptr ? default_value
-                                 : strcmp(string_value, "0") != 0;
-#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
+  return string_value == nullptr ? default_value 
+                                 : strcmp(string_value, "0") != 0; 
+#endif  // defined(GTEST_GET_BOOL_FROM_ENV_) 
 }
 
 // Reads and returns a 32-bit integer stored in the environment
 // variable corresponding to the given flag; if it isn't set or
 // doesn't represent a valid 32-bit integer, returns default_value.
-int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
+int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) { 
 #if defined(GTEST_GET_INT32_FROM_ENV_)
   return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
-#else
+#else 
   const std::string env_var = FlagToEnvVar(flag);
   const char* const string_value = posix::GetEnv(env_var.c_str());
-  if (string_value == nullptr) {
+  if (string_value == nullptr) { 
     // The environment variable is not set.
     return default_value;
   }
 
-  int32_t result = default_value;
+  int32_t result = default_value; 
   if (!ParseInt32(Message() << "Environment variable " << env_var,
                   string_value, &result)) {
     printf("The default value %s is used.\n",
@@ -1397,35 +1397,35 @@ int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
   }
 
   return result;
-#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
-}
-
-// As a special case for the 'output' flag, if GTEST_OUTPUT is not
-// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
-// system.  The value of XML_OUTPUT_FILE is a filename without the
-// "xml:" prefix of GTEST_OUTPUT.
-// Note that this is meant to be called at the call site so it does
-// not check that the flag is 'output'
-// In essence this checks an env variable called XML_OUTPUT_FILE
-// and if it is set we prepend "xml:" to its value, if it not set we return ""
-std::string OutputFlagAlsoCheckEnvVar(){
-  std::string default_value_for_output_flag = "";
-  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
-  if (nullptr != xml_output_file_env) {
-    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
-  }
-  return default_value_for_output_flag;
-}
-
+#endif  // defined(GTEST_GET_INT32_FROM_ENV_) 
+}
+
+// As a special case for the 'output' flag, if GTEST_OUTPUT is not 
+// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build 
+// system.  The value of XML_OUTPUT_FILE is a filename without the 
+// "xml:" prefix of GTEST_OUTPUT. 
+// Note that this is meant to be called at the call site so it does 
+// not check that the flag is 'output' 
+// In essence this checks an env variable called XML_OUTPUT_FILE 
+// and if it is set we prepend "xml:" to its value, if it not set we return "" 
+std::string OutputFlagAlsoCheckEnvVar(){ 
+  std::string default_value_for_output_flag = ""; 
+  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE"); 
+  if (nullptr != xml_output_file_env) { 
+    default_value_for_output_flag = std::string("xml:") + xml_output_file_env; 
+  } 
+  return default_value_for_output_flag; 
+} 
+ 
 // Reads and returns the string environment variable corresponding to
 // the given flag; if it's not set, returns default_value.
-const char* StringFromGTestEnv(const char* flag, const char* default_value) {
+const char* StringFromGTestEnv(const char* flag, const char* default_value) { 
 #if defined(GTEST_GET_STRING_FROM_ENV_)
   return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
-#else
-  const std::string env_var = FlagToEnvVar(flag);
-  const char* const value = posix::GetEnv(env_var.c_str());
-  return value == nullptr ? default_value : value;
+#else 
+  const std::string env_var = FlagToEnvVar(flag); 
+  const char* const value = posix::GetEnv(env_var.c_str()); 
+  return value == nullptr ? default_value : value; 
 #endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 }
 
diff --git a/contrib/restricted/googletest/googletest/src/gtest-printers.cc b/contrib/restricted/googletest/googletest/src/gtest-printers.cc
index 1b68fcb500..c8a1cc1a3b 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-printers.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-printers.cc
@@ -27,8 +27,8 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
-// Google Test - The Google C++ Testing and Mocking Framework
+ 
+// Google Test - The Google C++ Testing and Mocking Framework 
 //
 // This file implements a universal value printer that can print a
 // value of any type T:
@@ -42,18 +42,18 @@
 // defines Foo.
 
 #include "gtest/gtest-printers.h"
-
+ 
 #include <stdio.h>
-
-#include <cctype>
-#include <cstdint>
+ 
+#include <cctype> 
+#include <cstdint> 
 #include <cwchar>
 #include <ostream>  // NOLINT
 #include <string>
-#include <type_traits>
-
+#include <type_traits> 
+ 
 #include "gtest/internal/gtest-port.h"
-#include "src/gtest-internal-inl.h"
+#include "src/gtest-internal-inl.h" 
 
 namespace testing {
 
@@ -64,7 +64,7 @@ using ::std::ostream;
 // Prints a segment of bytes in the given object.
 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
 void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
                                 size_t count, ostream* os) {
@@ -107,19 +107,19 @@ void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
   *os << ">";
 }
 
-// Helpers for widening a character to char32_t. Since the standard does not
-// specify if char / wchar_t is signed or unsigned, it is important to first
-// convert it to the unsigned type of the same width before widening it to
-// char32_t.
-template <typename CharType>
-char32_t ToChar32(CharType in) {
-  return static_cast<char32_t>(
-      static_cast<typename std::make_unsigned<CharType>::type>(in));
-}
-
+// Helpers for widening a character to char32_t. Since the standard does not 
+// specify if char / wchar_t is signed or unsigned, it is important to first 
+// convert it to the unsigned type of the same width before widening it to 
+// char32_t. 
+template <typename CharType> 
+char32_t ToChar32(CharType in) { 
+  return static_cast<char32_t>( 
+      static_cast<typename std::make_unsigned<CharType>::type>(in)); 
+} 
+ 
 }  // namespace
 
-namespace internal {
+namespace internal { 
 
 // Delegates to PrintBytesInObjectToImpl() to print the bytes in the
 // given object.  The delegation simplifies the implementation, which
@@ -134,7 +134,7 @@ void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
 // Depending on the value of a char (or wchar_t), we print it in one
 // of three formats:
 //   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
-//   - as a hexadecimal escape sequence (e.g. '\x7F'), or
+//   - as a hexadecimal escape sequence (e.g. '\x7F'), or 
 //   - as a special escape sequence (e.g. '\r', '\n').
 enum CharFormat {
   kAsIs,
@@ -145,15 +145,15 @@ enum CharFormat {
 // Returns true if c is a printable ASCII character.  We test the
 // value of c directly instead of calling isprint(), which is buggy on
 // Windows Mobile.
-inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; }
+inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; } 
 
-// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a
-// character literal without the quotes, escaping it when necessary; returns how
-// c was formatted.
-template <typename Char>
+// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a 
+// character literal without the quotes, escaping it when necessary; returns how 
+// c was formatted. 
+template <typename Char> 
 static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
-  const char32_t u_c = ToChar32(c);
-  switch (u_c) {
+  const char32_t u_c = ToChar32(c); 
+  switch (u_c) { 
     case L'\0':
       *os << "\\0";
       break;
@@ -185,22 +185,22 @@ static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
       *os << "\\v";
       break;
     default:
-      if (IsPrintableAscii(u_c)) {
+      if (IsPrintableAscii(u_c)) { 
         *os << static_cast<char>(c);
         return kAsIs;
       } else {
-        ostream::fmtflags flags = os->flags();
-        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c);
-        os->flags(flags);
+        ostream::fmtflags flags = os->flags(); 
+        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c); 
+        os->flags(flags); 
         return kHexEscape;
       }
   }
   return kSpecialEscape;
 }
 
-// Prints a char32_t c as if it's part of a string literal, escaping it when
+// Prints a char32_t c as if it's part of a string literal, escaping it when 
 // necessary; returns how c was formatted.
-static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
+static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) { 
   switch (c) {
     case L'\'':
       *os << "'";
@@ -209,68 +209,68 @@ static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
       *os << "\\\"";
       return kSpecialEscape;
     default:
-      return PrintAsCharLiteralTo(c, os);
+      return PrintAsCharLiteralTo(c, os); 
   }
 }
 
-static const char* GetCharWidthPrefix(char) {
-  return "";
-}
-
-static const char* GetCharWidthPrefix(signed char) {
-  return "";
-}
-
-static const char* GetCharWidthPrefix(unsigned char) {
-  return "";
-}
-
-#ifdef __cpp_char8_t
-static const char* GetCharWidthPrefix(char8_t) {
-  return "u8";
-}
-#endif
-
-static const char* GetCharWidthPrefix(char16_t) {
-  return "u";
-}
-
-static const char* GetCharWidthPrefix(char32_t) {
-  return "U";
-}
-
-static const char* GetCharWidthPrefix(wchar_t) {
-  return "L";
-}
-
+static const char* GetCharWidthPrefix(char) { 
+  return ""; 
+} 
+ 
+static const char* GetCharWidthPrefix(signed char) { 
+  return ""; 
+} 
+ 
+static const char* GetCharWidthPrefix(unsigned char) { 
+  return ""; 
+} 
+ 
+#ifdef __cpp_char8_t 
+static const char* GetCharWidthPrefix(char8_t) { 
+  return "u8"; 
+} 
+#endif 
+ 
+static const char* GetCharWidthPrefix(char16_t) { 
+  return "u"; 
+} 
+ 
+static const char* GetCharWidthPrefix(char32_t) { 
+  return "U"; 
+} 
+ 
+static const char* GetCharWidthPrefix(wchar_t) { 
+  return "L"; 
+} 
+ 
 // Prints a char c as if it's part of a string literal, escaping it when
 // necessary; returns how c was formatted.
 static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
-  return PrintAsStringLiteralTo(ToChar32(c), os);
-}
-
-#ifdef __cpp_char8_t
-static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
-  return PrintAsStringLiteralTo(ToChar32(c), os);
-}
-#endif
-
-static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) {
-  return PrintAsStringLiteralTo(ToChar32(c), os);
-}
-
-static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
-  return PrintAsStringLiteralTo(ToChar32(c), os);
-}
-
-// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t)
-// and its code. '\0' is printed as "'\\0'", other unprintable characters are
-// also properly escaped using the standard C++ escape sequence.
-template <typename Char>
+  return PrintAsStringLiteralTo(ToChar32(c), os); 
+}
+
+#ifdef __cpp_char8_t 
+static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) { 
+  return PrintAsStringLiteralTo(ToChar32(c), os); 
+} 
+#endif 
+ 
+static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) { 
+  return PrintAsStringLiteralTo(ToChar32(c), os); 
+} 
+ 
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) { 
+  return PrintAsStringLiteralTo(ToChar32(c), os); 
+} 
+ 
+// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t) 
+// and its code. '\0' is printed as "'\\0'", other unprintable characters are 
+// also properly escaped using the standard C++ escape sequence. 
+template <typename Char> 
 void PrintCharAndCodeTo(Char c, ostream* os) {
   // First, print c as a literal in the most readable form we can find.
-  *os << GetCharWidthPrefix(c) << "'";
-  const CharFormat format = PrintAsCharLiteralTo(c, os);
+  *os << GetCharWidthPrefix(c) << "'"; 
+  const CharFormat format = PrintAsCharLiteralTo(c, os); 
   *os << "'";
 
   // To aid user debugging, we also print c's code in decimal, unless
@@ -280,61 +280,61 @@ void PrintCharAndCodeTo(Char c, ostream* os) {
     return;
   *os << " (" << static_cast<int>(c);
 
-  // For more convenience, we print c's code again in hexadecimal,
+  // For more convenience, we print c's code again in hexadecimal, 
   // unless c was already printed in the form '\x##' or the code is in
   // [1, 9].
   if (format == kHexEscape || (1 <= c && c <= 9)) {
     // Do nothing.
   } else {
-    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
+    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c)); 
   }
   *os << ")";
 }
 
-void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
-void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
+void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } 
+void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } 
 
 // Prints a wchar_t as a symbol if it is printable or as its internal
 // code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
-void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); }
-
-// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well.
-void PrintTo(char32_t c, ::std::ostream* os) {
-  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
-      << static_cast<uint32_t>(c);
-}
-
+void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); } 
+
+// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well. 
+void PrintTo(char32_t c, ::std::ostream* os) { 
+  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4) 
+      << static_cast<uint32_t>(c); 
+} 
+ 
 // Prints the given array of characters to the ostream.  CharType must be either
-// char, char8_t, char16_t, char32_t, or wchar_t.
+// char, char8_t, char16_t, char32_t, or wchar_t. 
 // The array starts at begin, the length is len, it may include '\0' characters
 // and may not be NUL-terminated.
 template <typename CharType>
 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
-static CharFormat PrintCharsAsStringTo(
+static CharFormat PrintCharsAsStringTo( 
     const CharType* begin, size_t len, ostream* os) {
-  const char* const quote_prefix = GetCharWidthPrefix(*begin);
-  *os << quote_prefix << "\"";
+  const char* const quote_prefix = GetCharWidthPrefix(*begin); 
+  *os << quote_prefix << "\""; 
   bool is_previous_hex = false;
-  CharFormat print_format = kAsIs;
+  CharFormat print_format = kAsIs; 
   for (size_t index = 0; index < len; ++index) {
     const CharType cur = begin[index];
     if (is_previous_hex && IsXDigit(cur)) {
       // Previous character is of '\x..' form and this character can be
       // interpreted as another hexadecimal digit in its number. Break string to
       // disambiguate.
-      *os << "\" " << quote_prefix << "\"";
+      *os << "\" " << quote_prefix << "\""; 
     }
     is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
-    // Remember if any characters required hex escaping.
-    if (is_previous_hex) {
-      print_format = kHexEscape;
-    }
+    // Remember if any characters required hex escaping. 
+    if (is_previous_hex) { 
+      print_format = kHexEscape; 
+    } 
   }
   *os << "\"";
-  return print_format;
+  return print_format; 
 }
 
 // Prints a (const) char/wchar_t array of 'len' elements, starting at address
@@ -342,7 +342,7 @@ static CharFormat PrintCharsAsStringTo(
 template <typename CharType>
 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
 GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
-GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ 
 GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
 static void UniversalPrintCharArray(
     const CharType* begin, size_t len, ostream* os) {
@@ -371,57 +371,57 @@ void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
   UniversalPrintCharArray(begin, len, os);
 }
 
-#ifdef __cpp_char8_t
-// Prints a (const) char8_t array of 'len' elements, starting at address
-// 'begin'.
-void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-#endif
-
-// Prints a (const) char16_t array of 'len' elements, starting at address
-// 'begin'.
-void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
-// Prints a (const) char32_t array of 'len' elements, starting at address
-// 'begin'.
-void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) {
-  UniversalPrintCharArray(begin, len, os);
-}
-
+#ifdef __cpp_char8_t 
+// Prints a (const) char8_t array of 'len' elements, starting at address 
+// 'begin'. 
+void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) { 
+  UniversalPrintCharArray(begin, len, os); 
+} 
+#endif 
+ 
+// Prints a (const) char16_t array of 'len' elements, starting at address 
+// 'begin'. 
+void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) { 
+  UniversalPrintCharArray(begin, len, os); 
+} 
+ 
+// Prints a (const) char32_t array of 'len' elements, starting at address 
+// 'begin'. 
+void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) { 
+  UniversalPrintCharArray(begin, len, os); 
+} 
+ 
 // Prints a (const) wchar_t array of 'len' elements, starting at address
 // 'begin'.
 void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
   UniversalPrintCharArray(begin, len, os);
 }
 
-namespace {
-
-// Prints a null-terminated C-style string to the ostream.
-template <typename Char>
-void PrintCStringTo(const Char* s, ostream* os) {
-  if (s == nullptr) {
+namespace { 
+ 
+// Prints a null-terminated C-style string to the ostream. 
+template <typename Char> 
+void PrintCStringTo(const Char* s, ostream* os) { 
+  if (s == nullptr) { 
     *os << "NULL";
   } else {
     *os << ImplicitCast_<const void*>(s) << " pointing to ";
-    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os); 
   }
 }
 
-}  // anonymous namespace
-
-void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
-
-#ifdef __cpp_char8_t
-void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
-#endif
-
-void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }
-
-void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }
-
+}  // anonymous namespace 
+ 
+void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); } 
+ 
+#ifdef __cpp_char8_t 
+void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); } 
+#endif 
+ 
+void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); } 
+ 
+void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } 
+ 
 // MSVC compiler can be configured to define whar_t as a typedef
 // of unsigned short. Defining an overload for const wchar_t* in that case
 // would cause pointers to unsigned shorts be printed as wide strings,
@@ -430,98 +430,98 @@ void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }
 // wchar_t is implemented as a native type.
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
 // Prints the given wide C string to the ostream.
-void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
+void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } 
 #endif  // wchar_t is native
 
-namespace {
-
-bool ContainsUnprintableControlCodes(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
-
-  for (size_t i = 0; i < length; i++) {
-    unsigned char ch = *s++;
-    if (std::iscntrl(ch)) {
-        switch (ch) {
-        case '\t':
-        case '\n':
-        case '\r':
-          break;
-        default:
-          return true;
-        }
-      }
-  }
-  return false;
-}
-
-bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
-
-bool IsValidUTF8(const char* str, size_t length) {
-  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
-
-  for (size_t i = 0; i < length;) {
-    unsigned char lead = s[i++];
-
-    if (lead <= 0x7f) {
-      continue;  // single-byte character (ASCII) 0..7F
-    }
-    if (lead < 0xc2) {
-      return false;  // trail byte or non-shortest form
-    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
-      ++i;  // 2-byte character
-    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
-               // check for non-shortest form and surrogate
-               (lead != 0xe0 || s[i] >= 0xa0) &&
-               (lead != 0xed || s[i] < 0xa0)) {
-      i += 2;  // 3-byte character
-    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
-               IsUTF8TrailByte(s[i]) &&
-               IsUTF8TrailByte(s[i + 1]) &&
-               IsUTF8TrailByte(s[i + 2]) &&
-               // check for non-shortest form
-               (lead != 0xf0 || s[i] >= 0x90) &&
-               (lead != 0xf4 || s[i] < 0x90)) {
-      i += 3;  // 4-byte character
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
-  if (!ContainsUnprintableControlCodes(str, length) &&
-      IsValidUTF8(str, length)) {
-    *os << "\n    As Text: \"" << str << "\"";
-  }
-}
-
-}  // anonymous namespace
-
-void PrintStringTo(const ::std::string& s, ostream* os) {
-  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
-    if (GTEST_FLAG(print_utf8)) {
-      ConditionalPrintAsText(s.data(), s.size(), os);
-    }
-  }
-}
-
-#ifdef __cpp_char8_t
-void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-#endif
-
-void PrintU16StringTo(const ::std::u16string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-
-void PrintU32StringTo(const ::std::u32string& s, ostream* os) {
-  PrintCharsAsStringTo(s.data(), s.size(), os);
-}
-
+namespace { 
+ 
+bool ContainsUnprintableControlCodes(const char* str, size_t length) { 
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str); 
+ 
+  for (size_t i = 0; i < length; i++) { 
+    unsigned char ch = *s++; 
+    if (std::iscntrl(ch)) { 
+        switch (ch) { 
+        case '\t': 
+        case '\n': 
+        case '\r': 
+          break; 
+        default: 
+          return true; 
+        } 
+      } 
+  } 
+  return false; 
+}
+
+bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; } 
+ 
+bool IsValidUTF8(const char* str, size_t length) { 
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str); 
+ 
+  for (size_t i = 0; i < length;) { 
+    unsigned char lead = s[i++]; 
+ 
+    if (lead <= 0x7f) { 
+      continue;  // single-byte character (ASCII) 0..7F 
+    } 
+    if (lead < 0xc2) { 
+      return false;  // trail byte or non-shortest form 
+    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) { 
+      ++i;  // 2-byte character 
+    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length && 
+               IsUTF8TrailByte(s[i]) && 
+               IsUTF8TrailByte(s[i + 1]) && 
+               // check for non-shortest form and surrogate 
+               (lead != 0xe0 || s[i] >= 0xa0) && 
+               (lead != 0xed || s[i] < 0xa0)) { 
+      i += 2;  // 3-byte character 
+    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length && 
+               IsUTF8TrailByte(s[i]) && 
+               IsUTF8TrailByte(s[i + 1]) && 
+               IsUTF8TrailByte(s[i + 2]) && 
+               // check for non-shortest form 
+               (lead != 0xf0 || s[i] >= 0x90) && 
+               (lead != 0xf4 || s[i] < 0x90)) { 
+      i += 3;  // 4-byte character 
+    } else { 
+      return false; 
+    } 
+  } 
+  return true; 
+}
+
+void ConditionalPrintAsText(const char* str, size_t length, ostream* os) { 
+  if (!ContainsUnprintableControlCodes(str, length) && 
+      IsValidUTF8(str, length)) { 
+    *os << "\n    As Text: \"" << str << "\""; 
+  } 
+}
+
+}  // anonymous namespace 
+ 
+void PrintStringTo(const ::std::string& s, ostream* os) { 
+  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) { 
+    if (GTEST_FLAG(print_utf8)) { 
+      ConditionalPrintAsText(s.data(), s.size(), os); 
+    } 
+  } 
+} 
+ 
+#ifdef __cpp_char8_t 
+void PrintU8StringTo(const ::std::u8string& s, ostream* os) { 
+  PrintCharsAsStringTo(s.data(), s.size(), os); 
+} 
+#endif 
+ 
+void PrintU16StringTo(const ::std::u16string& s, ostream* os) { 
+  PrintCharsAsStringTo(s.data(), s.size(), os); 
+} 
+ 
+void PrintU32StringTo(const ::std::u32string& s, ostream* os) { 
+  PrintCharsAsStringTo(s.data(), s.size(), os); 
+} 
+ 
 #if GTEST_HAS_STD_WSTRING
 void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
   PrintCharsAsStringTo(s.data(), s.size(), os);
diff --git a/contrib/restricted/googletest/googletest/src/gtest-test-part.cc b/contrib/restricted/googletest/googletest/src/gtest-test-part.cc
index a938683ced..5d2af9e861 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-test-part.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-test-part.cc
@@ -26,13 +26,13 @@
 // 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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 
 #include "gtest/gtest-test-part.h"
-
-#include "gtest/internal/gtest-port.h"
+ 
+#include "gtest/internal/gtest-port.h" 
 #include "src/gtest-internal-inl.h"
 
 namespace testing {
@@ -43,23 +43,23 @@ using internal::GetUnitTestImpl;
 // in it.
 std::string TestPartResult::ExtractSummary(const char* message) {
   const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
-  return stack_trace == nullptr ? message : std::string(message, stack_trace);
+  return stack_trace == nullptr ? message : std::string(message, stack_trace); 
 }
 
 // Prints a TestPartResult object.
 std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
-  return os << internal::FormatFileLocation(result.file_name(),
-                                            result.line_number())
-            << " "
-            << (result.type() == TestPartResult::kSuccess
-                    ? "Success"
-                    : result.type() == TestPartResult::kSkip
-                          ? "Skipped"
-                          : result.type() == TestPartResult::kFatalFailure
-                                ? "Fatal failure"
-                                : "Non-fatal failure")
-            << ":\n"
-            << result.message() << std::endl;
+  return os << internal::FormatFileLocation(result.file_name(), 
+                                            result.line_number()) 
+            << " " 
+            << (result.type() == TestPartResult::kSuccess 
+                    ? "Success" 
+                    : result.type() == TestPartResult::kSkip 
+                          ? "Skipped" 
+                          : result.type() == TestPartResult::kFatalFailure 
+                                ? "Fatal failure" 
+                                : "Non-fatal failure") 
+            << ":\n" 
+            << result.message() << std::endl; 
 }
 
 // Appends a TestPartResult to the array.
@@ -74,7 +74,7 @@ const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
     internal::posix::Abort();
   }
 
-  return array_[static_cast<size_t>(index)];
+  return array_[static_cast<size_t>(index)]; 
 }
 
 // Returns the number of TestPartResult objects in the array.
diff --git a/contrib/restricted/googletest/googletest/src/gtest-typed-test.cc b/contrib/restricted/googletest/googletest/src/gtest-typed-test.cc
index c02c3df659..daf202fa37 100644
--- a/contrib/restricted/googletest/googletest/src/gtest-typed-test.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest-typed-test.cc
@@ -27,9 +27,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-
+ 
 #include "gtest/gtest-typed-test.h"
-
+ 
 #include "gtest/gtest.h"
 
 namespace testing {
@@ -46,7 +46,7 @@ static const char* SkipSpaces(const char* str) {
 static std::vector<std::string> SplitIntoTestNames(const char* src) {
   std::vector<std::string> name_vec;
   src = SkipSpaces(src);
-  for (; src != nullptr; src = SkipComma(src)) {
+  for (; src != nullptr; src = SkipComma(src)) { 
     name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
   }
   return name_vec;
@@ -55,11 +55,11 @@ static std::vector<std::string> SplitIntoTestNames(const char* src) {
 // Verifies that registered_tests match the test names in
 // registered_tests_; returns registered_tests if successful, or
 // aborts the program otherwise.
-const char* TypedTestSuitePState::VerifyRegisteredTestNames(
-    const char* test_suite_name, const char* file, int line,
-    const char* registered_tests) {
-  RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
-
+const char* TypedTestSuitePState::VerifyRegisteredTestNames( 
+    const char* test_suite_name, const char* file, int line, 
+    const char* registered_tests) { 
+  RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line)); 
+ 
   typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
   registered_ = true;
 
@@ -76,11 +76,11 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames(
       continue;
     }
 
-    if (registered_tests_.count(name) != 0) {
+    if (registered_tests_.count(name) != 0) { 
       tests.insert(name);
     } else {
       errors << "No test named " << name
-             << " can be found in this test suite.\n";
+             << " can be found in this test suite.\n"; 
     }
   }
 
diff --git a/contrib/restricted/googletest/googletest/src/gtest.cc b/contrib/restricted/googletest/googletest/src/gtest.cc
index 856da12edb..166951b772 100644
--- a/contrib/restricted/googletest/googletest/src/gtest.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest.cc
@@ -26,9 +26,9 @@
 // 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)
+// The Google C++ Testing and Mocking Framework (Google Test) 
 
 #include "gtest/gtest.h"
 #include "gtest/internal/custom/gtest.h"
@@ -43,9 +43,9 @@
 #include <wctype.h>
 
 #include <algorithm>
-#include <chrono>  // NOLINT
-#include <cmath>
-#include <cstdint>
+#include <chrono>  // NOLINT 
+#include <cmath> 
+#include <cstdint> 
 #include <iomanip>
 #include <limits>
 #include <list>
@@ -79,13 +79,13 @@
 
 #elif GTEST_OS_WINDOWS  // We are on Windows proper.
 
-# include <windows.h>  // NOLINT
-# undef min
-
-#ifdef _MSC_VER
-# include <crtdbg.h>  // NOLINT
-#endif
-
+# include <windows.h>  // NOLINT 
+# undef min 
+ 
+#ifdef _MSC_VER 
+# include <crtdbg.h>  // NOLINT 
+#endif 
+ 
 # include <io.h>  // NOLINT
 # include <sys/timeb.h>  // NOLINT
 # include <sys/types.h>  // NOLINT
@@ -121,19 +121,19 @@
 # define vsnprintf _vsnprintf
 #endif  // GTEST_OS_WINDOWS
 
-#if GTEST_OS_MAC
-#ifndef GTEST_OS_IOS
-#include <crt_externs.h>
-#endif
-#endif
-
-#if GTEST_HAS_ABSL
+#if GTEST_OS_MAC 
+#ifndef GTEST_OS_IOS 
+#include <crt_externs.h> 
+#endif 
+#endif 
+ 
+#if GTEST_HAS_ABSL 
 #error #include "absl/debugging/failure_signal_handler.h"
 #error #include "absl/debugging/stacktrace.h"
 #error #include "absl/debugging/symbolize.h"
 #error #include "absl/strings/str_cat.h"
-#endif  // GTEST_HAS_ABSL
-
+#endif  // GTEST_HAS_ABSL 
+ 
 namespace testing {
 
 using internal::CountIf;
@@ -143,22 +143,22 @@ using internal::Shuffle;
 
 // Constants.
 
-// A test whose test suite name or test name matches this filter is
+// A test whose test suite name or test name matches this filter is 
 // disabled and not run.
 static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
 
-// A test suite whose name matches this filter is considered a death
-// test suite and will be run before test suites whose name doesn't
+// A test suite whose name matches this filter is considered a death 
+// test suite and will be run before test suites whose name doesn't 
 // match this filter.
-static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
+static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*"; 
 
 // A test filter that matches everything.
 static const char kUniversalFilter[] = "*";
 
-// The default output format.
-static const char kDefaultOutputFormat[] = "xml";
-// The default output file.
-static const char kDefaultOutputFile[] = "test_detail";
+// The default output format. 
+static const char kDefaultOutputFormat[] = "xml"; 
+// The default output file. 
+static const char kDefaultOutputFile[] = "test_detail"; 
 
 // The environment variable name for the test shard index.
 static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
@@ -173,67 +173,67 @@ namespace internal {
 // stack trace.
 const char kStackTraceMarker[] = "\nStack trace:\n";
 
-// g_help_flag is true if and only if the --help flag or an equivalent form
-// is specified on the command line.
+// g_help_flag is true if and only if the --help flag or an equivalent form 
+// is specified on the command line. 
 bool g_help_flag = false;
 
-// Utilty function to Open File for Writing
-static FILE* OpenFileForWriting(const std::string& output_file) {
-  FILE* fileout = nullptr;
-  FilePath output_file_path(output_file);
-  FilePath output_dir(output_file_path.RemoveFileName());
-
-  if (output_dir.CreateDirectoriesRecursively()) {
-    fileout = posix::FOpen(output_file.c_str(), "w");
-  }
-  if (fileout == nullptr) {
-    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
-  }
-  return fileout;
-}
-
+// Utilty function to Open File for Writing 
+static FILE* OpenFileForWriting(const std::string& output_file) { 
+  FILE* fileout = nullptr; 
+  FilePath output_file_path(output_file); 
+  FilePath output_dir(output_file_path.RemoveFileName()); 
+ 
+  if (output_dir.CreateDirectoriesRecursively()) { 
+    fileout = posix::FOpen(output_file.c_str(), "w"); 
+  } 
+  if (fileout == nullptr) { 
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\""; 
+  } 
+  return fileout; 
+} 
+ 
 }  // namespace internal
 
-// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
-// environment variable.
+// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY 
+// environment variable. 
 static const char* GetDefaultFilter() {
-  const char* const testbridge_test_only =
-      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
-  if (testbridge_test_only != nullptr) {
+  const char* const testbridge_test_only = 
+      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); 
+  if (testbridge_test_only != nullptr) { 
     return testbridge_test_only;
   }
   return kUniversalFilter;
 }
 
-// Bazel passes in the argument to '--test_runner_fail_fast' via the
-// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
-static bool GetDefaultFailFast() {
-  const char* const testbridge_test_runner_fail_fast =
-      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
-  if (testbridge_test_runner_fail_fast != nullptr) {
-    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
-  }
-  return false;
-}
-
-GTEST_DEFINE_bool_(
-    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
-    "True if and only if a test failure should stop further test execution.");
-
+// Bazel passes in the argument to '--test_runner_fail_fast' via the 
+// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable. 
+static bool GetDefaultFailFast() { 
+  const char* const testbridge_test_runner_fail_fast = 
+      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST"); 
+  if (testbridge_test_runner_fail_fast != nullptr) { 
+    return strcmp(testbridge_test_runner_fail_fast, "1") == 0; 
+  } 
+  return false; 
+} 
+ 
 GTEST_DEFINE_bool_(
+    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()), 
+    "True if and only if a test failure should stop further test execution."); 
+ 
+GTEST_DEFINE_bool_( 
     also_run_disabled_tests,
     internal::BoolFromGTestEnv("also_run_disabled_tests", false),
     "Run disabled tests too, in addition to the tests normally being run.");
 
 GTEST_DEFINE_bool_(
-    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
-    "True if and only if a failed assertion should be a debugger "
-    "break-point.");
+    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false), 
+    "True if and only if a failed assertion should be a debugger " 
+    "break-point."); 
 
-GTEST_DEFINE_bool_(catch_exceptions,
-                   internal::BoolFromGTestEnv("catch_exceptions", true),
-                   "True if and only if " GTEST_NAME_
-                   " should catch exceptions and treat them as test failures.");
+GTEST_DEFINE_bool_(catch_exceptions, 
+                   internal::BoolFromGTestEnv("catch_exceptions", true), 
+                   "True if and only if " GTEST_NAME_ 
+                   " should catch exceptions and treat them as test failures."); 
 
 GTEST_DEFINE_string_(
     color,
@@ -252,46 +252,46 @@ GTEST_DEFINE_string_(
     "exclude).  A test is run if it matches one of the positive "
     "patterns and does not match any of the negative patterns.");
 
-GTEST_DEFINE_bool_(
-    install_failure_signal_handler,
-    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
-    "If true and supported on the current platform, " GTEST_NAME_ " should "
-    "install a signal handler that dumps debugging information when fatal "
-    "signals are raised.");
-
+GTEST_DEFINE_bool_( 
+    install_failure_signal_handler, 
+    internal::BoolFromGTestEnv("install_failure_signal_handler", false), 
+    "If true and supported on the current platform, " GTEST_NAME_ " should " 
+    "install a signal handler that dumps debugging information when fatal " 
+    "signals are raised."); 
+ 
 GTEST_DEFINE_bool_(list_tests, false,
                    "List all tests without running them.");
 
-// The net priority order after flag processing is thus:
-//   --gtest_output command line flag
-//   GTEST_OUTPUT environment variable
-//   XML_OUTPUT_FILE environment variable
-//   ''
+// The net priority order after flag processing is thus: 
+//   --gtest_output command line flag 
+//   GTEST_OUTPUT environment variable 
+//   XML_OUTPUT_FILE environment variable 
+//   '' 
 GTEST_DEFINE_string_(
     output,
-    internal::StringFromGTestEnv("output",
-      internal::OutputFlagAlsoCheckEnvVar().c_str()),
-    "A format (defaults to \"xml\" but can be specified to be \"json\"), "
-    "optionally followed by a colon and an output file name or directory. "
-    "A directory is indicated by a trailing pathname separator. "
+    internal::StringFromGTestEnv("output", 
+      internal::OutputFlagAlsoCheckEnvVar().c_str()), 
+    "A format (defaults to \"xml\" but can be specified to be \"json\"), " 
+    "optionally followed by a colon and an output file name or directory. " 
+    "A directory is indicated by a trailing pathname separator. " 
     "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
     "If a directory is specified, output files will be created "
     "within that directory, with file-names based on the test "
     "executable's name and, if necessary, made unique by adding "
     "digits.");
 
-GTEST_DEFINE_bool_(
-    brief, internal::BoolFromGTestEnv("brief", false),
-    "True if only test failures should be displayed in text output.");
-
-GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
-                   "True if and only if " GTEST_NAME_
-                   " should display elapsed time in text output.");
-
-GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
-                   "True if and only if " GTEST_NAME_
-                   " prints UTF8 characters as text.");
-
+GTEST_DEFINE_bool_( 
+    brief, internal::BoolFromGTestEnv("brief", false), 
+    "True if only test failures should be displayed in text output."); 
+ 
+GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true), 
+                   "True if and only if " GTEST_NAME_ 
+                   " should display elapsed time in text output."); 
+
+GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true), 
+                   "True if and only if " GTEST_NAME_ 
+                   " prints UTF8 characters as text."); 
+ 
 GTEST_DEFINE_int32_(
     random_seed,
     internal::Int32FromGTestEnv("random_seed", 0),
@@ -304,14 +304,14 @@ GTEST_DEFINE_int32_(
     "How many times to repeat each test.  Specify a negative number "
     "for repeating forever.  Useful for shaking out flaky tests.");
 
-GTEST_DEFINE_bool_(show_internal_stack_frames, false,
-                   "True if and only if " GTEST_NAME_
-                   " should include internal stack frames when "
-                   "printing test failure stack traces.");
+GTEST_DEFINE_bool_(show_internal_stack_frames, false, 
+                   "True if and only if " GTEST_NAME_ 
+                   " should include internal stack frames when " 
+                   "printing test failure stack traces."); 
 
-GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
-                   "True if and only if " GTEST_NAME_
-                   " should randomize tests' order on every run.");
+GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false), 
+                   "True if and only if " GTEST_NAME_ 
+                   " should randomize tests' order on every run."); 
 
 GTEST_DEFINE_int32_(
     stack_trace_depth,
@@ -331,7 +331,7 @@ GTEST_DEFINE_bool_(
     internal::BoolFromGTestEnv("throw_on_failure", false),
     "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.");
+    "otherwise. For use with an external test framework."); 
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
 GTEST_DEFINE_string_(
@@ -345,10 +345,10 @@ namespace internal {
 // Generates a random number from [0, range), using a Linear
 // Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
 // than kMaxRange.
-uint32_t Random::Generate(uint32_t range) {
+uint32_t Random::Generate(uint32_t range) { 
   // These constants are the same as are used in glibc's rand(3).
-  // Use wider types than necessary to prevent unsigned overflow diagnostics.
-  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
+  // Use wider types than necessary to prevent unsigned overflow diagnostics. 
+  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange; 
 
   GTEST_CHECK_(range > 0)
       << "Cannot generate a number in the range [0, 0).";
@@ -362,16 +362,16 @@ uint32_t Random::Generate(uint32_t range) {
   return state_ % range;
 }
 
-// GTestIsInitialized() returns true if and only if the user has initialized
+// GTestIsInitialized() returns true if and only if the user has initialized 
 // Google Test.  Useful for catching the user mistake of not initializing
 // Google Test before calling RUN_ALL_TESTS().
 static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
 
-// Iterates over a vector of TestSuites, keeping a running sum of the
+// Iterates over a vector of TestSuites, keeping a running sum of the 
 // results of calling a given int-returning method on each.
 // Returns the sum.
-static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
-                                int (TestSuite::*method)() const) {
+static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list, 
+                                int (TestSuite::*method)() const) { 
   int sum = 0;
   for (size_t i = 0; i < case_list.size(); i++) {
     sum += (case_list[i]->*method)();
@@ -379,20 +379,20 @@ static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
   return sum;
 }
 
-// Returns true if and only if the test suite passed.
-static bool TestSuitePassed(const TestSuite* test_suite) {
-  return test_suite->should_run() && test_suite->Passed();
+// Returns true if and only if the test suite passed. 
+static bool TestSuitePassed(const TestSuite* test_suite) { 
+  return test_suite->should_run() && test_suite->Passed(); 
 }
 
-// Returns true if and only if the test suite failed.
-static bool TestSuiteFailed(const TestSuite* test_suite) {
-  return test_suite->should_run() && test_suite->Failed();
+// Returns true if and only if the test suite failed. 
+static bool TestSuiteFailed(const TestSuite* test_suite) { 
+  return test_suite->should_run() && test_suite->Failed(); 
 }
 
-// Returns true if and only if test_suite contains at least one test that
-// should run.
-static bool ShouldRunTestSuite(const TestSuite* test_suite) {
-  return test_suite->should_run();
+// Returns true if and only if test_suite contains at least one test that 
+// should run. 
+static bool ShouldRunTestSuite(const TestSuite* test_suite) { 
+  return test_suite->should_run(); 
 }
 
 // AssertHelper constructor.
@@ -418,172 +418,172 @@ void AssertHelper::operator=(const Message& message) const {
                       );  // NOLINT
 }
 
-namespace {
-
-// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
-// to creates test cases for it, a syntetic test case is
-// inserted to report ether an error or a log message.
-//
-// This configuration bit will likely be removed at some point.
-constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
-constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;
-
-// A test that fails at a given file/line location with a given message.
-class FailureTest : public Test {
- public:
-  explicit FailureTest(const CodeLocation& loc, std::string error_message,
-                       bool as_error)
-      : loc_(loc),
-        error_message_(std::move(error_message)),
-        as_error_(as_error) {}
-
-  void TestBody() override {
-    if (as_error_) {
-      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
-                   loc_.line, "") = Message() << error_message_;
-    } else {
-      std::cout << error_message_ << std::endl;
-    }
-  }
-
- private:
-  const CodeLocation loc_;
-  const std::string error_message_;
-  const bool as_error_;
-};
-
-
-}  // namespace
-
-std::set<std::string>* GetIgnoredParameterizedTestSuites() {
-  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
-}
-
-// Add a given test_suit to the list of them allow to go un-instantiated.
-MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
-  GetIgnoredParameterizedTestSuites()->insert(test_suite);
-}
-
-// If this parameterized test suite has no instantiations (and that
-// has not been marked as okay), emit a test case reporting that.
-void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
-                             bool has_test_p) {
-  const auto& ignored = *GetIgnoredParameterizedTestSuites();
-  if (ignored.find(name) != ignored.end()) return;
-
-  const char kMissingInstantiation[] =  //
-      " is defined via TEST_P, but never instantiated. None of the test cases "
-      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
-      "ones provided expand to nothing."
-      "\n\n"
-      "Ideally, TEST_P definitions should only ever be included as part of "
-      "binaries that intend to use them. (As opposed to, for example, being "
-      "placed in a library that may be linked in to get other utilities.)";
-
-  const char kMissingTestCase[] =  //
-      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
-      "defined via TEST_P . No test cases will run."
-      "\n\n"
-      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
-      "code that always depend on code that provides TEST_P. Failing to do "
-      "so is often an indication of dead code, e.g. the last TEST_P was "
-      "removed but the rest got left behind.";
-
-  std::string message =
-      "Parameterized test suite " + name +
-      (has_test_p ? kMissingInstantiation : kMissingTestCase) +
-      "\n\n"
-      "To suppress this error for this test suite, insert the following line "
-      "(in a non-header) in the namespace it is defined in:"
-      "\n\n"
-      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
-
-  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
-  RegisterTest(  //
-      "GoogleTestVerification", full_name.c_str(),
-      nullptr,  // No type parameter.
-      nullptr,  // No value parameter.
-      location.file.c_str(), location.line, [message, location] {
-        return new FailureTest(location, message,
-                               kErrorOnUninstantiatedParameterizedTest);
-      });
-}
-
-void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
-                                        CodeLocation code_location) {
-  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
-      test_suite_name, code_location);
-}
-
-void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
-  GetUnitTestImpl()
-      ->type_parameterized_test_registry()
-      .RegisterInstantiation(case_name);
-}
-
-void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
-    const char* test_suite_name, CodeLocation code_location) {
-  suites_.emplace(std::string(test_suite_name),
-                 TypeParameterizedTestSuiteInfo(code_location));
-}
-
-void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
-        const char* test_suite_name) {
-  auto it = suites_.find(std::string(test_suite_name));
-  if (it != suites_.end()) {
-    it->second.instantiated = true;
-  } else {
-    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
-                      << test_suite_name << "'";
-  }
-}
-
-void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
-  const auto& ignored = *GetIgnoredParameterizedTestSuites();
-  for (const auto& testcase : suites_) {
-    if (testcase.second.instantiated) continue;
-    if (ignored.find(testcase.first) != ignored.end()) continue;
-
-    std::string message =
-        "Type parameterized test suite " + testcase.first +
-        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
-        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
-        "\n\n"
-        "Ideally, TYPED_TEST_P definitions should only ever be included as "
-        "part of binaries that intend to use them. (As opposed to, for "
-        "example, being placed in a library that may be linked in to get other "
-        "utilities.)"
-        "\n\n"
-        "To suppress this error for this test suite, insert the following line "
-        "(in a non-header) in the namespace it is defined in:"
-        "\n\n"
-        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
-        testcase.first + ");";
-
-    std::string full_name =
-        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
-    RegisterTest(  //
-        "GoogleTestVerification", full_name.c_str(),
-        nullptr,  // No type parameter.
-        nullptr,  // No value parameter.
-        testcase.second.code_location.file.c_str(),
-        testcase.second.code_location.line, [message, testcase] {
-          return new FailureTest(testcase.second.code_location, message,
-                                 kErrorOnUninstantiatedTypeParameterizedTest);
-        });
-  }
-}
-
+namespace { 
+ 
+// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P 
+// to creates test cases for it, a syntetic test case is 
+// inserted to report ether an error or a log message. 
+// 
+// This configuration bit will likely be removed at some point. 
+constexpr bool kErrorOnUninstantiatedParameterizedTest = true; 
+constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true; 
+ 
+// A test that fails at a given file/line location with a given message. 
+class FailureTest : public Test { 
+ public: 
+  explicit FailureTest(const CodeLocation& loc, std::string error_message, 
+                       bool as_error) 
+      : loc_(loc), 
+        error_message_(std::move(error_message)), 
+        as_error_(as_error) {} 
+ 
+  void TestBody() override { 
+    if (as_error_) { 
+      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(), 
+                   loc_.line, "") = Message() << error_message_; 
+    } else { 
+      std::cout << error_message_ << std::endl; 
+    } 
+  } 
+ 
+ private: 
+  const CodeLocation loc_; 
+  const std::string error_message_; 
+  const bool as_error_; 
+}; 
+ 
+ 
+}  // namespace 
+ 
+std::set<std::string>* GetIgnoredParameterizedTestSuites() { 
+  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites(); 
+} 
+ 
+// Add a given test_suit to the list of them allow to go un-instantiated. 
+MarkAsIgnored::MarkAsIgnored(const char* test_suite) { 
+  GetIgnoredParameterizedTestSuites()->insert(test_suite); 
+} 
+ 
+// If this parameterized test suite has no instantiations (and that 
+// has not been marked as okay), emit a test case reporting that. 
+void InsertSyntheticTestCase(const std::string& name, CodeLocation location, 
+                             bool has_test_p) { 
+  const auto& ignored = *GetIgnoredParameterizedTestSuites(); 
+  if (ignored.find(name) != ignored.end()) return; 
+ 
+  const char kMissingInstantiation[] =  // 
+      " is defined via TEST_P, but never instantiated. None of the test cases " 
+      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only " 
+      "ones provided expand to nothing." 
+      "\n\n" 
+      "Ideally, TEST_P definitions should only ever be included as part of " 
+      "binaries that intend to use them. (As opposed to, for example, being " 
+      "placed in a library that may be linked in to get other utilities.)"; 
+ 
+  const char kMissingTestCase[] =  // 
+      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are " 
+      "defined via TEST_P . No test cases will run." 
+      "\n\n" 
+      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from " 
+      "code that always depend on code that provides TEST_P. Failing to do " 
+      "so is often an indication of dead code, e.g. the last TEST_P was " 
+      "removed but the rest got left behind."; 
+ 
+  std::string message = 
+      "Parameterized test suite " + name + 
+      (has_test_p ? kMissingInstantiation : kMissingTestCase) + 
+      "\n\n" 
+      "To suppress this error for this test suite, insert the following line " 
+      "(in a non-header) in the namespace it is defined in:" 
+      "\n\n" 
+      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");"; 
+ 
+  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">"; 
+  RegisterTest(  // 
+      "GoogleTestVerification", full_name.c_str(), 
+      nullptr,  // No type parameter. 
+      nullptr,  // No value parameter. 
+      location.file.c_str(), location.line, [message, location] { 
+        return new FailureTest(location, message, 
+                               kErrorOnUninstantiatedParameterizedTest); 
+      }); 
+} 
+ 
+void RegisterTypeParameterizedTestSuite(const char* test_suite_name, 
+                                        CodeLocation code_location) { 
+  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite( 
+      test_suite_name, code_location); 
+} 
+ 
+void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) { 
+  GetUnitTestImpl() 
+      ->type_parameterized_test_registry() 
+      .RegisterInstantiation(case_name); 
+} 
+ 
+void TypeParameterizedTestSuiteRegistry::RegisterTestSuite( 
+    const char* test_suite_name, CodeLocation code_location) { 
+  suites_.emplace(std::string(test_suite_name), 
+                 TypeParameterizedTestSuiteInfo(code_location)); 
+} 
+ 
+void TypeParameterizedTestSuiteRegistry::RegisterInstantiation( 
+        const char* test_suite_name) { 
+  auto it = suites_.find(std::string(test_suite_name)); 
+  if (it != suites_.end()) { 
+    it->second.instantiated = true; 
+  } else { 
+    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '" 
+                      << test_suite_name << "'"; 
+  } 
+} 
+ 
+void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() { 
+  const auto& ignored = *GetIgnoredParameterizedTestSuites(); 
+  for (const auto& testcase : suites_) { 
+    if (testcase.second.instantiated) continue; 
+    if (ignored.find(testcase.first) != ignored.end()) continue; 
+ 
+    std::string message = 
+        "Type parameterized test suite " + testcase.first + 
+        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated " 
+        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run." 
+        "\n\n" 
+        "Ideally, TYPED_TEST_P definitions should only ever be included as " 
+        "part of binaries that intend to use them. (As opposed to, for " 
+        "example, being placed in a library that may be linked in to get other " 
+        "utilities.)" 
+        "\n\n" 
+        "To suppress this error for this test suite, insert the following line " 
+        "(in a non-header) in the namespace it is defined in:" 
+        "\n\n" 
+        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + 
+        testcase.first + ");"; 
+ 
+    std::string full_name = 
+        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">"; 
+    RegisterTest(  // 
+        "GoogleTestVerification", full_name.c_str(), 
+        nullptr,  // No type parameter. 
+        nullptr,  // No value parameter. 
+        testcase.second.code_location.file.c_str(), 
+        testcase.second.code_location.line, [message, testcase] { 
+          return new FailureTest(testcase.second.code_location, message, 
+                                 kErrorOnUninstantiatedTypeParameterizedTest); 
+        }); 
+  } 
+} 
+ 
 // A copy of all command line arguments.  Set by InitGoogleTest().
-static ::std::vector<std::string> g_argvs;
+static ::std::vector<std::string> g_argvs; 
 
-::std::vector<std::string> GetArgvs() {
+::std::vector<std::string> GetArgvs() { 
 #if defined(GTEST_CUSTOM_GET_ARGVS_)
-  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
-  // ::string. This code converts it to the appropriate type.
-  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
-  return ::std::vector<std::string>(custom.begin(), custom.end());
-#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
+  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or 
+  // ::string. This code converts it to the appropriate type. 
+  const auto& custom = GTEST_CUSTOM_GET_ARGVS_(); 
+  return ::std::vector<std::string>(custom.begin(), custom.end()); 
+#else   // defined(GTEST_CUSTOM_GET_ARGVS_) 
   return g_argvs;
 #endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
 }
@@ -593,7 +593,7 @@ static ::std::vector<std::string> g_argvs;
 FilePath GetCurrentExecutableName() {
   FilePath result;
 
-#if GTEST_OS_WINDOWS || GTEST_OS_OS2
+#if GTEST_OS_WINDOWS || GTEST_OS_OS2 
   result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
 #else
   result.Set(FilePath(GetArgvs()[0]));
@@ -608,10 +608,10 @@ FilePath GetCurrentExecutableName() {
 std::string UnitTestOptions::GetOutputFormat() {
   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
   const char* const colon = strchr(gtest_output_flag, ':');
-  return (colon == nullptr)
-             ? std::string(gtest_output_flag)
-             : std::string(gtest_output_flag,
-                           static_cast<size_t>(colon - gtest_output_flag));
+  return (colon == nullptr) 
+             ? std::string(gtest_output_flag) 
+             : std::string(gtest_output_flag, 
+                           static_cast<size_t>(colon - gtest_output_flag)); 
 }
 
 // Returns the name of the requested output file, or the default if none
@@ -619,17 +619,17 @@ std::string UnitTestOptions::GetOutputFormat() {
 std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
   const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
 
-  std::string format = GetOutputFormat();
-  if (format.empty())
-    format = std::string(kDefaultOutputFormat);
-
+  std::string format = GetOutputFormat(); 
+  if (format.empty()) 
+    format = std::string(kDefaultOutputFormat); 
+ 
   const char* const colon = strchr(gtest_output_flag, ':');
-  if (colon == nullptr)
-    return internal::FilePath::MakeFileName(
+  if (colon == nullptr) 
+    return internal::FilePath::MakeFileName( 
         internal::FilePath(
             UnitTest::GetInstance()->original_working_dir()),
-        internal::FilePath(kDefaultOutputFile), 0,
-        format.c_str()).string();
+        internal::FilePath(kDefaultOutputFile), 0, 
+        format.c_str()).string(); 
 
   internal::FilePath output_name(colon + 1);
   if (!output_name.IsAbsolutePath())
@@ -646,89 +646,89 @@ std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
   return result.string();
 }
 
-// Returns true if and only if the wildcard pattern matches the string. Each
-// pattern consists of regular characters, single-character wildcards (?), and
-// multi-character wildcards (*).
+// Returns true if and only if the wildcard pattern matches the string. Each 
+// pattern consists of regular characters, single-character wildcards (?), and 
+// multi-character wildcards (*). 
 //
-// This function implements a linear-time string globbing algorithm based on
-// https://research.swtch.com/glob.
-static bool PatternMatchesString(const std::string& name_str,
-                                 const char* pattern, const char* pattern_end) {
-  const char* name = name_str.c_str();
-  const char* const name_begin = name;
-  const char* const name_end = name + name_str.size();
-
-  const char* pattern_next = pattern;
-  const char* name_next = name;
-
-  while (pattern < pattern_end || name < name_end) {
-    if (pattern < pattern_end) {
-      switch (*pattern) {
-        default:  // Match an ordinary character.
-          if (name < name_end && *name == *pattern) {
-            ++pattern;
-            ++name;
-            continue;
-          }
-          break;
-        case '?':  // Match any single character.
-          if (name < name_end) {
-            ++pattern;
-            ++name;
-            continue;
-          }
-          break;
-        case '*':
-          // Match zero or more characters. Start by skipping over the wildcard
-          // and matching zero characters from name. If that fails, restart and
-          // match one more character than the last attempt.
-          pattern_next = pattern;
-          name_next = name + 1;
-          ++pattern;
-          continue;
-      }
-    }
-    // Failed to match a character. Restart if possible.
-    if (name_begin < name_next && name_next <= name_end) {
-      pattern = pattern_next;
-      name = name_next;
-      continue;
-    }
-    return false;
-  }
-  return true;
-}
-
-bool UnitTestOptions::MatchesFilter(const std::string& name_str,
-                                    const char* filter) {
-  // The filter is a list of patterns separated by colons (:).
-  const char* pattern = filter;
-  while (true) {
-    // Find the bounds of this pattern.
-    const char* const next_sep = strchr(pattern, ':');
-    const char* const pattern_end =
-        next_sep != nullptr ? next_sep : pattern + strlen(pattern);
-
-    // Check if this pattern matches name_str.
-    if (PatternMatchesString(name_str, pattern, pattern_end)) {
+// This function implements a linear-time string globbing algorithm based on 
+// https://research.swtch.com/glob. 
+static bool PatternMatchesString(const std::string& name_str, 
+                                 const char* pattern, const char* pattern_end) { 
+  const char* name = name_str.c_str(); 
+  const char* const name_begin = name; 
+  const char* const name_end = name + name_str.size(); 
+ 
+  const char* pattern_next = pattern; 
+  const char* name_next = name; 
+ 
+  while (pattern < pattern_end || name < name_end) { 
+    if (pattern < pattern_end) { 
+      switch (*pattern) { 
+        default:  // Match an ordinary character. 
+          if (name < name_end && *name == *pattern) { 
+            ++pattern; 
+            ++name; 
+            continue; 
+          } 
+          break; 
+        case '?':  // Match any single character. 
+          if (name < name_end) { 
+            ++pattern; 
+            ++name; 
+            continue; 
+          } 
+          break; 
+        case '*': 
+          // Match zero or more characters. Start by skipping over the wildcard 
+          // and matching zero characters from name. If that fails, restart and 
+          // match one more character than the last attempt. 
+          pattern_next = pattern; 
+          name_next = name + 1; 
+          ++pattern; 
+          continue; 
+      } 
+    } 
+    // Failed to match a character. Restart if possible. 
+    if (name_begin < name_next && name_next <= name_end) { 
+      pattern = pattern_next; 
+      name = name_next; 
+      continue; 
+    } 
+    return false; 
+  }
+  return true; 
+}
+
+bool UnitTestOptions::MatchesFilter(const std::string& name_str, 
+                                    const char* filter) { 
+  // The filter is a list of patterns separated by colons (:). 
+  const char* pattern = filter; 
+  while (true) { 
+    // Find the bounds of this pattern. 
+    const char* const next_sep = strchr(pattern, ':'); 
+    const char* const pattern_end = 
+        next_sep != nullptr ? next_sep : pattern + strlen(pattern); 
+ 
+    // Check if this pattern matches name_str. 
+    if (PatternMatchesString(name_str, pattern, pattern_end)) { 
       return true;
     }
 
-    // Give up on this pattern. However, if we found a pattern separator (:),
-    // advance to the next pattern (skipping over the separator) and restart.
-    if (next_sep == nullptr) {
+    // Give up on this pattern. However, if we found a pattern separator (:), 
+    // advance to the next pattern (skipping over the separator) and restart. 
+    if (next_sep == nullptr) { 
       return false;
     }
-    pattern = next_sep + 1;
+    pattern = next_sep + 1; 
   }
-  return true;
+  return true; 
 }
 
-// Returns true if and only if the user-specified filter matches the test
-// suite name and the test name.
-bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
-                                        const std::string& test_name) {
-  const std::string& full_name = test_suite_name + "." + test_name.c_str();
+// Returns true if and only if the user-specified filter matches the test 
+// suite name and the test name. 
+bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name, 
+                                        const std::string& test_name) { 
+  const std::string& full_name = test_suite_name + "." + test_name.c_str(); 
 
   // Split --gtest_filter at '-', if there is one, to separate into
   // positive filter and negative filter portions
@@ -736,7 +736,7 @@ bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
   const char* const dash = strchr(p, '-');
   std::string positive;
   std::string negative;
-  if (dash == nullptr) {
+  if (dash == nullptr) { 
     positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
     negative = "";
   } else {
@@ -855,12 +855,12 @@ extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
 // This predicate-formatter checks that 'results' contains a test part
 // failure of the given type and that the failure message contains the
 // given substring.
-static AssertionResult HasOneFailure(const char* /* results_expr */,
-                                     const char* /* type_expr */,
-                                     const char* /* substr_expr */,
-                                     const TestPartResultArray& results,
-                                     TestPartResult::Type type,
-                                     const std::string& substr) {
+static AssertionResult HasOneFailure(const char* /* results_expr */, 
+                                     const char* /* type_expr */, 
+                                     const char* /* substr_expr */, 
+                                     const TestPartResultArray& results, 
+                                     TestPartResult::Type type, 
+                                     const std::string& substr) { 
   const std::string expected(type == TestPartResult::kFatalFailure ?
                         "1 fatal failure" :
                         "1 non-fatal failure");
@@ -881,7 +881,7 @@ static AssertionResult HasOneFailure(const char* /* results_expr */,
                               << r;
   }
 
-  if (strstr(r.message(), substr.c_str()) == nullptr) {
+  if (strstr(r.message(), substr.c_str()) == nullptr) { 
     return AssertionFailure() << "Expected: " << expected << " containing \""
                               << substr << "\"\n"
                               << "  Actual:\n"
@@ -894,10 +894,10 @@ static AssertionResult HasOneFailure(const char* /* results_expr */,
 // The constructor of SingleFailureChecker remembers where to look up
 // test part results, what type of failure we expect, and what
 // substring the failure message should contain.
-SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
-                                           TestPartResult::Type type,
-                                           const std::string& substr)
-    : results_(results), type_(type), substr_(substr) {}
+SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results, 
+                                           TestPartResult::Type type, 
+                                           const std::string& substr) 
+    : results_(results), type_(type), substr_(substr) {} 
 
 // The destructor of SingleFailureChecker verifies that the given
 // TestPartResultArray contains exactly one failure that has the given
@@ -950,66 +950,66 @@ void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
   per_thread_test_part_result_reporter_.set(reporter);
 }
 
-// Gets the number of successful test suites.
-int UnitTestImpl::successful_test_suite_count() const {
-  return CountIf(test_suites_, TestSuitePassed);
+// Gets the number of successful test suites. 
+int UnitTestImpl::successful_test_suite_count() const { 
+  return CountIf(test_suites_, TestSuitePassed); 
 }
 
-// Gets the number of failed test suites.
-int UnitTestImpl::failed_test_suite_count() const {
-  return CountIf(test_suites_, TestSuiteFailed);
+// Gets the number of failed test suites. 
+int UnitTestImpl::failed_test_suite_count() const { 
+  return CountIf(test_suites_, TestSuiteFailed); 
 }
 
-// Gets the number of all test suites.
-int UnitTestImpl::total_test_suite_count() const {
-  return static_cast<int>(test_suites_.size());
+// Gets the number of all test suites. 
+int UnitTestImpl::total_test_suite_count() const { 
+  return static_cast<int>(test_suites_.size()); 
 }
 
-// Gets the number of all test suites that contain at least one test
+// Gets the number of all test suites that contain at least one test 
 // that should run.
-int UnitTestImpl::test_suite_to_run_count() const {
-  return CountIf(test_suites_, ShouldRunTestSuite);
+int UnitTestImpl::test_suite_to_run_count() const { 
+  return CountIf(test_suites_, ShouldRunTestSuite); 
 }
 
 // Gets the number of successful tests.
 int UnitTestImpl::successful_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
-}
-
-// Gets the number of skipped tests.
-int UnitTestImpl::skipped_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count); 
 }
 
+// Gets the number of skipped tests. 
+int UnitTestImpl::skipped_test_count() const { 
+  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count); 
+} 
+ 
 // Gets the number of failed tests.
 int UnitTestImpl::failed_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count); 
 }
 
 // Gets the number of disabled tests that will be reported in the XML report.
 int UnitTestImpl::reportable_disabled_test_count() const {
-  return SumOverTestSuiteList(test_suites_,
-                              &TestSuite::reportable_disabled_test_count);
+  return SumOverTestSuiteList(test_suites_, 
+                              &TestSuite::reportable_disabled_test_count); 
 }
 
 // Gets the number of disabled tests.
 int UnitTestImpl::disabled_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count); 
 }
 
 // Gets the number of tests to be printed in the XML report.
 int UnitTestImpl::reportable_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count); 
 }
 
 // Gets the number of all tests.
 int UnitTestImpl::total_test_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count); 
 }
 
 // Gets the number of tests that should run.
 int UnitTestImpl::test_to_run_count() const {
-  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
+  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count); 
 }
 
 // Returns the current OS stack trace as an std::string.
@@ -1031,30 +1031,30 @@ std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
       );  // NOLINT
 }
 
-// A helper class for measuring elapsed times.
-class Timer {
- public:
-  Timer() : start_(std::chrono::steady_clock::now()) {}
+// A helper class for measuring elapsed times. 
+class Timer { 
+ public: 
+  Timer() : start_(std::chrono::steady_clock::now()) {} 
 
-  // Return time elapsed in milliseconds since the timer was created.
-  TimeInMillis Elapsed() {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-               std::chrono::steady_clock::now() - start_)
-        .count();
+  // Return time elapsed in milliseconds since the timer was created. 
+  TimeInMillis Elapsed() { 
+    return std::chrono::duration_cast<std::chrono::milliseconds>( 
+               std::chrono::steady_clock::now() - start_) 
+        .count(); 
   }
 
- private:
-  std::chrono::steady_clock::time_point start_;
-};
+ private: 
+  std::chrono::steady_clock::time_point start_; 
+}; 
 
-// Returns a timestamp as milliseconds since the epoch. Note this time may jump
-// around subject to adjustments by the system, to measure elapsed time use
-// Timer instead.
-TimeInMillis GetTimeInMillis() {
-  return std::chrono::duration_cast<std::chrono::milliseconds>(
-             std::chrono::system_clock::now() -
-             std::chrono::system_clock::from_time_t(0))
-      .count();
+// Returns a timestamp as milliseconds since the epoch. Note this time may jump 
+// around subject to adjustments by the system, to measure elapsed time use 
+// Timer instead. 
+TimeInMillis GetTimeInMillis() { 
+  return std::chrono::duration_cast<std::chrono::milliseconds>( 
+             std::chrono::system_clock::now() - 
+             std::chrono::system_clock::from_time_t(0)) 
+      .count(); 
 }
 
 // Utilities
@@ -1067,10 +1067,10 @@ TimeInMillis GetTimeInMillis() {
 // value using delete[]. Returns the wide string, or NULL if the
 // input is NULL.
 LPCWSTR String::AnsiToUtf16(const char* ansi) {
-  if (!ansi) return nullptr;
+  if (!ansi) return nullptr; 
   const int length = strlen(ansi);
   const int unicode_length =
-      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
+      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0); 
   WCHAR* unicode = new WCHAR[unicode_length + 1];
   MultiByteToWideChar(CP_ACP, 0, ansi, length,
                       unicode, unicode_length);
@@ -1083,33 +1083,33 @@ LPCWSTR String::AnsiToUtf16(const char* ansi) {
 // value using delete[]. Returns the ANSI string, or NULL if the
 // input is NULL.
 const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
-  if (!utf16_str) return nullptr;
-  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
-                                              0, nullptr, nullptr);
+  if (!utf16_str) return nullptr; 
+  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr, 
+                                              0, nullptr, nullptr); 
   char* ansi = new char[ansi_length + 1];
-  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
-                      nullptr);
+  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr, 
+                      nullptr); 
   ansi[ansi_length] = 0;
   return ansi;
 }
 
 #endif  // GTEST_OS_WINDOWS_MOBILE
 
-// Compares two C strings.  Returns true if and only if they have the same
-// content.
+// Compares two C strings.  Returns true if and only if they have the same 
+// content. 
 //
 // Unlike strcmp(), this function can handle NULL argument(s).  A NULL
 // C string is considered different to any non-NULL C string,
 // including the empty string.
 bool String::CStringEquals(const char * lhs, const char * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
+  if (lhs == nullptr) return rhs == nullptr; 
 
-  if (rhs == nullptr) return false;
+  if (rhs == nullptr) return false; 
 
   return strcmp(lhs, rhs) == 0;
 }
 
-#if GTEST_HAS_STD_WSTRING
+#if GTEST_HAS_STD_WSTRING 
 
 // Converts an array of wide chars to a narrow string using the UTF-8
 // encoding, and streams the result to the given Message object.
@@ -1127,7 +1127,7 @@ static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
   }
 }
 
-#endif  // GTEST_HAS_STD_WSTRING
+#endif  // GTEST_HAS_STD_WSTRING 
 
 void SplitString(const ::std::string& str, char delimiter,
                  ::std::vector< ::std::string>* dest) {
@@ -1187,21 +1187,21 @@ std::string Message::GetString() const {
 // Used in EXPECT_TRUE/FALSE(assertion_result).
 AssertionResult::AssertionResult(const AssertionResult& other)
     : success_(other.success_),
-      message_(other.message_.get() != nullptr
-                   ? new ::std::string(*other.message_)
-                   : static_cast< ::std::string*>(nullptr)) {}
+      message_(other.message_.get() != nullptr 
+                   ? new ::std::string(*other.message_) 
+                   : static_cast< ::std::string*>(nullptr)) {} 
 
 // Swaps two AssertionResults.
 void AssertionResult::swap(AssertionResult& other) {
   using std::swap;
   swap(success_, other.success_);
-  swap(message_, other.message_);
+  swap(message_, other.message_); 
 }
 
 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
 AssertionResult AssertionResult::operator!() const {
   AssertionResult negation(!success_);
-  if (message_.get() != nullptr) negation << *message_;
+  if (message_.get() != nullptr) negation << *message_; 
   return negation;
 }
 
@@ -1370,7 +1370,7 @@ class Hunk {
   // Print a unified diff header for one hunk.
   // The format is
   //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
-  // where the left/right parts are omitted if unnecessary.
+  // where the left/right parts are omitted if unnecessary. 
   void PrintHeader(std::ostream* ss) const {
     *ss << "@@ ";
     if (removes_) {
@@ -1427,10 +1427,10 @@ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
     for (; edit_i < edits.size(); ++edit_i) {
       if (n_suffix >= context) {
         // Continue only if the next hunk is very close.
-        auto it = edits.begin() + static_cast<int>(edit_i);
+        auto it = edits.begin() + static_cast<int>(edit_i); 
         while (it != edits.end() && *it == kMatch) ++it;
-        if (it == edits.end() ||
-            static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
+        if (it == edits.end() || 
+            static_cast<size_t>(it - edits.begin()) - edit_i >= context) { 
           // There is no next edit or it is too far away.
           break;
         }
@@ -1506,7 +1506,7 @@ std::vector<std::string> SplitEscapedString(const std::string& str) {
 //   lhs_value:      "5"
 //   rhs_value:      "6"
 //
-// The ignoring_case parameter is true if and only if the assertion is a
+// The ignoring_case parameter is true if and only if the assertion is a 
 // *_STRCASEEQ*.  When it's true, the string "Ignoring case" will
 // be inserted into the message.
 AssertionResult EqFailure(const char* lhs_expression,
@@ -1515,14 +1515,14 @@ AssertionResult EqFailure(const char* lhs_expression,
                           const std::string& rhs_value,
                           bool ignoring_case) {
   Message msg;
-  msg << "Expected equality of these values:";
-  msg << "\n  " << lhs_expression;
+  msg << "Expected equality of these values:"; 
+  msg << "\n  " << lhs_expression; 
   if (lhs_value != lhs_expression) {
-    msg << "\n    Which is: " << lhs_value;
+    msg << "\n    Which is: " << lhs_value; 
   }
-  msg << "\n  " << rhs_expression;
+  msg << "\n  " << rhs_expression; 
   if (rhs_value != rhs_expression) {
-    msg << "\n    Which is: " << rhs_value;
+    msg << "\n    Which is: " << rhs_value; 
   }
 
   if (ignoring_case) {
@@ -1569,31 +1569,31 @@ AssertionResult DoubleNearPredFormat(const char* expr1,
   const double diff = fabs(val1 - val2);
   if (diff <= abs_error) return AssertionSuccess();
 
-  // Find the value which is closest to zero.
-  const double min_abs = std::min(fabs(val1), fabs(val2));
-  // Find the distance to the next double from that value.
-  const double epsilon =
-      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
-  // Detect the case where abs_error is so small that EXPECT_NEAR is
-  // effectively the same as EXPECT_EQUAL, and give an informative error
-  // message so that the situation can be more easily understood without
-  // requiring exotic floating-point knowledge.
-  // Don't do an epsilon check if abs_error is zero because that implies
-  // that an equality check was actually intended.
-  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
-      abs_error < epsilon) {
-    return AssertionFailure()
-           << "The difference between " << expr1 << " and " << expr2 << " is "
-           << diff << ", where\n"
-           << expr1 << " evaluates to " << val1 << ",\n"
-           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
-           << abs_error_expr << " evaluates to " << abs_error
-           << " which is smaller than the minimum distance between doubles for "
-              "numbers of this magnitude which is "
-           << epsilon
-           << ", thus making this EXPECT_NEAR check equivalent to "
-              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
-  }
+  // Find the value which is closest to zero. 
+  const double min_abs = std::min(fabs(val1), fabs(val2)); 
+  // Find the distance to the next double from that value. 
+  const double epsilon = 
+      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs; 
+  // Detect the case where abs_error is so small that EXPECT_NEAR is 
+  // effectively the same as EXPECT_EQUAL, and give an informative error 
+  // message so that the situation can be more easily understood without 
+  // requiring exotic floating-point knowledge. 
+  // Don't do an epsilon check if abs_error is zero because that implies 
+  // that an equality check was actually intended. 
+  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 && 
+      abs_error < epsilon) { 
+    return AssertionFailure() 
+           << "The difference between " << expr1 << " and " << expr2 << " is " 
+           << diff << ", where\n" 
+           << expr1 << " evaluates to " << val1 << ",\n" 
+           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter " 
+           << abs_error_expr << " evaluates to " << abs_error 
+           << " which is smaller than the minimum distance between doubles for " 
+              "numbers of this magnitude which is " 
+           << epsilon 
+           << ", thus making this EXPECT_NEAR check equivalent to " 
+              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead."; 
+  } 
   return AssertionFailure()
       << "The difference between " << expr1 << " and " << expr2
       << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
@@ -1723,20 +1723,20 @@ namespace {
 
 // Helper functions for implementing IsSubString() and IsNotSubstring().
 
-// This group of overloaded functions return true if and only if needle
-// is a substring of haystack.  NULL is considered a substring of
-// itself only.
+// This group of overloaded functions return true if and only if needle 
+// is a substring of haystack.  NULL is considered a substring of 
+// itself only. 
 
 bool IsSubstringPred(const char* needle, const char* haystack) {
-  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+  if (needle == nullptr || haystack == nullptr) return needle == haystack; 
 
-  return strstr(haystack, needle) != nullptr;
+  return strstr(haystack, needle) != nullptr; 
 }
 
 bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
-  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+  if (needle == nullptr || haystack == nullptr) return needle == haystack; 
 
-  return wcsstr(haystack, needle) != nullptr;
+  return wcsstr(haystack, needle) != nullptr; 
 }
 
 // StringType here can be either ::std::string or ::std::wstring.
@@ -1834,7 +1834,7 @@ namespace {
 AssertionResult HRESULTFailureHelper(const char* expr,
                                      const char* expected,
                                      long hr) {  // NOLINT
-# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
+# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE 
 
   // Windows CE doesn't support FormatMessage.
   const char error_text[] = "";
@@ -1850,12 +1850,12 @@ AssertionResult HRESULTFailureHelper(const char* expr,
   // Gets the system's human readable message string for this HRESULT.
   char error_text[kBufSize] = { '\0' };
   DWORD message_length = ::FormatMessageA(kFlags,
-                                          0,   // no source, we're asking system
-                                          static_cast<DWORD>(hr),  // the error
-                                          0,   // no line width restrictions
+                                          0,   // no source, we're asking system 
+                                          static_cast<DWORD>(hr),  // the error 
+                                          0,   // no line width restrictions 
                                           error_text,  // output buffer
-                                          kBufSize,    // buf size
-                                          nullptr);  // no arguments for inserts
+                                          kBufSize,    // buf size 
+                                          nullptr);  // no arguments for inserts 
   // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
   for (; message_length && IsSpace(error_text[message_length - 1]);
           --message_length) {
@@ -1891,7 +1891,7 @@ AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
 // Utility functions for encoding Unicode text (wide strings) in
 // UTF-8.
 
-// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
+// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8 
 // like this:
 //
 // Code-point length   Encoding
@@ -1901,35 +1901,35 @@ AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
 //  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 
 // The maximum code-point a one-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1;
+constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1; 
 
 // The maximum code-point a two-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
+constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1; 
 
 // The maximum code-point a three-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
+constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1; 
 
 // The maximum code-point a four-byte UTF-8 sequence can represent.
-constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
+constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1; 
 
 // Chops off the n lowest bits from a bit pattern.  Returns the n
 // lowest bits.  As a side effect, the original bit pattern will be
 // shifted to the right by n bits.
-inline uint32_t ChopLowBits(uint32_t* bits, int n) {
-  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
+inline uint32_t ChopLowBits(uint32_t* bits, int n) { 
+  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1); 
   *bits >>= n;
   return low_bits;
 }
 
 // Converts a Unicode code point to a narrow string in UTF-8 encoding.
-// code_point parameter is of type uint32_t because wchar_t may not be
+// code_point parameter is of type uint32_t because wchar_t may not be 
 // wide enough to contain a code point.
 // If the code_point is not a valid Unicode code point
 // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
 // to "(Invalid Unicode 0xXXXXXXXX)".
-std::string CodePointToUtf8(uint32_t code_point) {
+std::string CodePointToUtf8(uint32_t code_point) { 
   if (code_point > kMaxCodePoint4) {
-    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
+    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")"; 
   }
 
   char str[5];  // Big enough for the largest valid code point.
@@ -1955,9 +1955,9 @@ std::string CodePointToUtf8(uint32_t code_point) {
   return str;
 }
 
-// The following two functions only make sense if the system
+// The following two functions only make sense if the system 
 // uses UTF-16 for wide string encoding. All supported systems
-// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
+// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16. 
 
 // Determines if the arguments constitute UTF-16 surrogate pair
 // and thus should be combined into a single Unicode code point
@@ -1968,22 +1968,22 @@ inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
 }
 
 // Creates a Unicode code point from UTF16 surrogate pair.
-inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
-                                                      wchar_t second) {
-  const auto first_u = static_cast<uint32_t>(first);
-  const auto second_u = static_cast<uint32_t>(second);
-  const uint32_t mask = (1 << 10) - 1;
-  return (sizeof(wchar_t) == 2)
-             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
-             :
-             // This function should not be called when the condition is
-             // false, but we provide a sensible default in case it is.
-             first_u;
+inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first, 
+                                                      wchar_t second) { 
+  const auto first_u = static_cast<uint32_t>(first); 
+  const auto second_u = static_cast<uint32_t>(second); 
+  const uint32_t mask = (1 << 10) - 1; 
+  return (sizeof(wchar_t) == 2) 
+             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000 
+             : 
+             // This function should not be called when the condition is 
+             // false, but we provide a sensible default in case it is. 
+             first_u; 
 }
 
 // Converts a wide string to a narrow string in UTF-8 encoding.
 // The wide string is assumed to have the following encoding:
-//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin) 
 //   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
 // Parameter str points to a null-terminated wide string.
 // Parameter num_chars may additionally limit the number
@@ -2000,7 +2000,7 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
 
   ::std::stringstream stream;
   for (int i = 0; i < num_chars; ++i) {
-    uint32_t unicode_code_point;
+    uint32_t unicode_code_point; 
 
     if (str[i] == L'\0') {
       break;
@@ -2009,7 +2009,7 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
                                                                  str[i + 1]);
       i++;
     } else {
-      unicode_code_point = static_cast<uint32_t>(str[i]);
+      unicode_code_point = static_cast<uint32_t>(str[i]); 
     }
 
     stream << CodePointToUtf8(unicode_code_point);
@@ -2020,21 +2020,21 @@ std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
 // Converts a wide C string to an std::string using the UTF-8 encoding.
 // NULL will be converted to "(null)".
 std::string String::ShowWideCString(const wchar_t * wide_c_str) {
-  if (wide_c_str == nullptr) return "(null)";
+  if (wide_c_str == nullptr) return "(null)"; 
 
   return internal::WideStringToUtf8(wide_c_str, -1);
 }
 
-// Compares two wide C strings.  Returns true if and only if they have the
-// same content.
+// Compares two wide C strings.  Returns true if and only if they have the 
+// same content. 
 //
 // Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
 // C string is considered different to any non-NULL C string,
 // including the empty string.
 bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
+  if (lhs == nullptr) return rhs == nullptr; 
 
-  if (rhs == nullptr) return false;
+  if (rhs == nullptr) return false; 
 
   return wcscmp(lhs, rhs) == 0;
 }
@@ -2070,35 +2070,35 @@ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                             << " vs " << PrintToString(s2);
 }
 
-// Compares two C strings, ignoring case.  Returns true if and only if they have
+// Compares two C strings, ignoring case.  Returns true if and only if they have 
 // the same content.
 //
 // Unlike strcasecmp(), this function can handle NULL argument(s).  A
 // NULL C string is considered different to any non-NULL C string,
 // including the empty string.
 bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
-  if (rhs == nullptr) return false;
+  if (lhs == nullptr) return rhs == nullptr; 
+  if (rhs == nullptr) return false; 
   return posix::StrCaseCmp(lhs, rhs) == 0;
 }
 
-// Compares two wide C strings, ignoring case.  Returns true if and only if they
-// have the same content.
-//
-// Unlike wcscasecmp(), this function can handle NULL argument(s).
-// A NULL C string is considered different to any non-NULL wide C string,
-// including the empty string.
-// NB: The implementations on different platforms slightly differ.
-// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
-// environment variable. On GNU platform this method uses wcscasecmp
-// which compares according to LC_CTYPE category of the current locale.
-// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
-// current locale.
+// Compares two wide C strings, ignoring case.  Returns true if and only if they 
+// have the same content. 
+// 
+// Unlike wcscasecmp(), this function can handle NULL argument(s). 
+// A NULL C string is considered different to any non-NULL wide C string, 
+// including the empty string. 
+// NB: The implementations on different platforms slightly differ. 
+// On windows, this method uses _wcsicmp which compares according to LC_CTYPE 
+// environment variable. On GNU platform this method uses wcscasecmp 
+// which compares according to LC_CTYPE category of the current locale. 
+// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the 
+// current locale. 
 bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
                                               const wchar_t* rhs) {
-  if (lhs == nullptr) return rhs == nullptr;
+  if (lhs == nullptr) return rhs == nullptr; 
 
-  if (rhs == nullptr) return false;
+  if (rhs == nullptr) return false; 
 
 #if GTEST_OS_WINDOWS
   return _wcsicmp(lhs, rhs) == 0;
@@ -2109,14 +2109,14 @@ bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
   // Other unknown OSes may not define it either.
   wint_t left, right;
   do {
-    left = towlower(static_cast<wint_t>(*lhs++));
-    right = towlower(static_cast<wint_t>(*rhs++));
+    left = towlower(static_cast<wint_t>(*lhs++)); 
+    right = towlower(static_cast<wint_t>(*rhs++)); 
   } while (left && left == right);
   return left == right;
 #endif  // OS selector
 }
 
-// Returns true if and only if str ends with the given suffix, ignoring case.
+// Returns true if and only if str ends with the given suffix, ignoring case. 
 // Any string is considered to end with an empty suffix.
 bool String::EndsWithCaseInsensitive(
     const std::string& str, const std::string& suffix) {
@@ -2129,28 +2129,28 @@ bool String::EndsWithCaseInsensitive(
 
 // Formats an int value as "%02d".
 std::string String::FormatIntWidth2(int value) {
-  return FormatIntWidthN(value, 2);
-}
-
-// Formats an int value to given width with leading zeros.
-std::string String::FormatIntWidthN(int value, int width) {
+  return FormatIntWidthN(value, 2); 
+} 
+ 
+// Formats an int value to given width with leading zeros. 
+std::string String::FormatIntWidthN(int value, int width) { 
   std::stringstream ss;
-  ss << std::setfill('0') << std::setw(width) << value;
+  ss << std::setfill('0') << std::setw(width) << value; 
   return ss.str();
 }
 
 // Formats an int value as "%X".
-std::string String::FormatHexUInt32(uint32_t value) {
+std::string String::FormatHexUInt32(uint32_t value) { 
   std::stringstream ss;
   ss << std::hex << std::uppercase << value;
   return ss.str();
 }
 
-// Formats an int value as "%X".
-std::string String::FormatHexInt(int value) {
-  return FormatHexUInt32(static_cast<uint32_t>(value));
-}
-
+// Formats an int value as "%X". 
+std::string String::FormatHexInt(int value) { 
+  return FormatHexUInt32(static_cast<uint32_t>(value)); 
+} 
+ 
 // Formats a byte as "%02X".
 std::string String::FormatByte(unsigned char value) {
   std::stringstream ss;
@@ -2167,7 +2167,7 @@ std::string StringStreamToString(::std::stringstream* ss) {
   const char* const end = start + str.length();
 
   std::string result;
-  result.reserve(static_cast<size_t>(2 * (end - start)));
+  result.reserve(static_cast<size_t>(2 * (end - start))); 
   for (const char* ch = start; ch != end; ++ch) {
     if (*ch == '\0') {
       result += "\\0";  // Replaces NUL with "\\0";
@@ -2187,9 +2187,9 @@ std::string AppendUserMessage(const std::string& gtest_msg,
   if (user_msg_string.empty()) {
     return gtest_msg;
   }
-  if (gtest_msg.empty()) {
-    return user_msg_string;
-  }
+  if (gtest_msg.empty()) { 
+    return user_msg_string; 
+  } 
   return gtest_msg + "\n" + user_msg_string;
 }
 
@@ -2199,7 +2199,7 @@ std::string AppendUserMessage(const std::string& gtest_msg,
 
 // Creates an empty TestResult.
 TestResult::TestResult()
-    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
+    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {} 
 
 // D'tor.
 TestResult::~TestResult() {
@@ -2211,7 +2211,7 @@ TestResult::~TestResult() {
 const TestPartResult& TestResult::GetTestPartResult(int i) const {
   if (i < 0 || i >= total_part_count())
     internal::posix::Abort();
-  return test_part_results_.at(static_cast<size_t>(i));
+  return test_part_results_.at(static_cast<size_t>(i)); 
 }
 
 // Returns the i-th test property. i can range from 0 to
@@ -2220,7 +2220,7 @@ const TestPartResult& TestResult::GetTestPartResult(int i) const {
 const TestProperty& TestResult::GetTestProperty(int i) const {
   if (i < 0 || i >= test_property_count())
     internal::posix::Abort();
-  return test_properties_.at(static_cast<size_t>(i));
+  return test_properties_.at(static_cast<size_t>(i)); 
 }
 
 // Clears the test part results.
@@ -2241,7 +2241,7 @@ void TestResult::RecordProperty(const std::string& xml_element,
   if (!ValidateTestProperty(xml_element, test_property)) {
     return;
   }
-  internal::MutexLock lock(&test_properties_mutex_);
+  internal::MutexLock lock(&test_properties_mutex_); 
   const std::vector<TestProperty>::iterator property_with_matching_key =
       std::find_if(test_properties_.begin(), test_properties_.end(),
                    internal::TestPropertyKeyIs(test_property.key()));
@@ -2268,21 +2268,21 @@ static const char* const kReservedTestSuitesAttributes[] = {
 // The list of reserved attributes used in the <testsuite> element of XML
 // output.
 static const char* const kReservedTestSuiteAttributes[] = {
-    "disabled", "errors", "failures",  "name",
-    "tests",    "time",   "timestamp", "skipped"};
+    "disabled", "errors", "failures",  "name", 
+    "tests",    "time",   "timestamp", "skipped"}; 
 
 // The list of reserved attributes used in the <testcase> element of XML output.
 static const char* const kReservedTestCaseAttributes[] = {
-    "classname",   "name", "status", "time",  "type_param",
-    "value_param", "file", "line"};
-
-// Use a slightly different set for allowed output to ensure existing tests can
-// still RecordProperty("result") or "RecordProperty(timestamp")
-static const char* const kReservedOutputTestCaseAttributes[] = {
-    "classname",   "name", "status", "time",   "type_param",
-    "value_param", "file", "line",   "result", "timestamp"};
-
-template <size_t kSize>
+    "classname",   "name", "status", "time",  "type_param", 
+    "value_param", "file", "line"}; 
+
+// Use a slightly different set for allowed output to ensure existing tests can 
+// still RecordProperty("result") or "RecordProperty(timestamp") 
+static const char* const kReservedOutputTestCaseAttributes[] = { 
+    "classname",   "name", "status", "time",   "type_param", 
+    "value_param", "file", "line",   "result", "timestamp"}; 
+ 
+template <size_t kSize> 
 std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
   return std::vector<std::string>(array, array + kSize);
 }
@@ -2302,22 +2302,22 @@ static std::vector<std::string> GetReservedAttributesForElement(
   return std::vector<std::string>();
 }
 
-// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
-static std::vector<std::string> GetReservedOutputAttributesForElement(
-    const std::string& xml_element) {
-  if (xml_element == "testsuites") {
-    return ArrayAsVector(kReservedTestSuitesAttributes);
-  } else if (xml_element == "testsuite") {
-    return ArrayAsVector(kReservedTestSuiteAttributes);
-  } else if (xml_element == "testcase") {
-    return ArrayAsVector(kReservedOutputTestCaseAttributes);
-  } else {
-    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
-  }
-  // This code is unreachable but some compilers may not realizes that.
-  return std::vector<std::string>();
-}
-
+// TODO(jdesprez): Merge the two getReserved attributes once skip is improved 
+static std::vector<std::string> GetReservedOutputAttributesForElement( 
+    const std::string& xml_element) { 
+  if (xml_element == "testsuites") { 
+    return ArrayAsVector(kReservedTestSuitesAttributes); 
+  } else if (xml_element == "testsuite") { 
+    return ArrayAsVector(kReservedTestSuiteAttributes); 
+  } else if (xml_element == "testcase") { 
+    return ArrayAsVector(kReservedOutputTestCaseAttributes); 
+  } else { 
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; 
+  } 
+  // This code is unreachable but some compilers may not realizes that. 
+  return std::vector<std::string>(); 
+} 
+ 
 static std::string FormatWordList(const std::vector<std::string>& words) {
   Message word_list;
   for (size_t i = 0; i < words.size(); ++i) {
@@ -2332,9 +2332,9 @@ static std::string FormatWordList(const std::vector<std::string>& words) {
   return word_list.GetString();
 }
 
-static bool ValidateTestPropertyName(
-    const std::string& property_name,
-    const std::vector<std::string>& reserved_names) {
+static bool ValidateTestPropertyName( 
+    const std::string& property_name, 
+    const std::vector<std::string>& reserved_names) { 
   if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
           reserved_names.end()) {
     ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
@@ -2361,17 +2361,17 @@ void TestResult::Clear() {
   elapsed_time_ = 0;
 }
 
-// Returns true off the test part was skipped.
-static bool TestPartSkipped(const TestPartResult& result) {
-  return result.skipped();
-}
-
-// Returns true if and only if the test was skipped.
-bool TestResult::Skipped() const {
-  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
-}
-
-// Returns true if and only if the test failed.
+// Returns true off the test part was skipped. 
+static bool TestPartSkipped(const TestPartResult& result) { 
+  return result.skipped(); 
+} 
+ 
+// Returns true if and only if the test was skipped. 
+bool TestResult::Skipped() const { 
+  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0; 
+} 
+ 
+// Returns true if and only if the test failed. 
 bool TestResult::Failed() const {
   for (int i = 0; i < total_part_count(); ++i) {
     if (GetTestPartResult(i).failed())
@@ -2380,22 +2380,22 @@ bool TestResult::Failed() const {
   return false;
 }
 
-// Returns true if and only if the test part fatally failed.
+// Returns true if and only if the test part fatally failed. 
 static bool TestPartFatallyFailed(const TestPartResult& result) {
   return result.fatally_failed();
 }
 
-// Returns true if and only if the test fatally failed.
+// Returns true if and only if the test fatally failed. 
 bool TestResult::HasFatalFailure() const {
   return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
 }
 
-// Returns true if and only if the test part non-fatally failed.
+// Returns true if and only if the test part non-fatally failed. 
 static bool TestPartNonfatallyFailed(const TestPartResult& result) {
   return result.nonfatally_failed();
 }
 
-// Returns true if and only if the test has a non-fatal failure.
+// Returns true if and only if the test has a non-fatal failure. 
 bool TestResult::HasNonfatalFailure() const {
   return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
 }
@@ -2458,25 +2458,25 @@ void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
   // AddTestPartResult.
   UnitTest::GetInstance()->AddTestPartResult(
       result_type,
-      nullptr,  // No info about the source file where the exception occurred.
-      -1,       // We have no info on which line caused the exception.
+      nullptr,  // No info about the source file where the exception occurred. 
+      -1,       // We have no info on which line caused the exception. 
       message,
-      "");  // No stack trace, either.
+      "");  // No stack trace, either. 
 }
 
 }  // namespace internal
 
-// Google Test requires all tests in the same test suite to use the same test
+// Google Test requires all tests in the same test suite to use the same test 
 // fixture class.  This function checks if the current test has the
-// same fixture class as the first test in the current test suite.  If
+// same fixture class as the first test in the current test suite.  If 
 // yes, it returns true; otherwise it generates a Google Test failure and
 // returns false.
 bool Test::HasSameFixtureClass() {
   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  const TestSuite* const test_suite = impl->current_test_suite();
+  const TestSuite* const test_suite = impl->current_test_suite(); 
 
-  // Info about the first test in the current test suite.
-  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
+  // Info about the first test in the current test suite. 
+  const TestInfo* const first_test_info = test_suite->test_info_list()[0]; 
   const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
   const char* const first_test_name = first_test_info->name();
 
@@ -2492,7 +2492,7 @@ bool Test::HasSameFixtureClass() {
     const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
 
     if (first_is_TEST || this_is_TEST) {
-      // Both TEST and TEST_F appear in same test suite, which is incorrect.
+      // Both TEST and TEST_F appear in same test suite, which is incorrect. 
       // Tell the user how to fix this.
 
       // Gets the name of the TEST and the name of the TEST_F.  Note
@@ -2504,9 +2504,9 @@ bool Test::HasSameFixtureClass() {
           first_is_TEST ? this_test_name : first_test_name;
 
       ADD_FAILURE()
-          << "All tests in the same test suite must use the same test fixture\n"
-          << "class, so mixing TEST_F and TEST in the same test suite is\n"
-          << "illegal.  In test suite " << this_test_info->test_suite_name()
+          << "All tests in the same test suite must use the same test fixture\n" 
+          << "class, so mixing TEST_F and TEST in the same test suite is\n" 
+          << "illegal.  In test suite " << this_test_info->test_suite_name() 
           << ",\n"
           << "test " << TEST_F_name << " is defined using TEST_F but\n"
           << "test " << TEST_name << " is defined using TEST.  You probably\n"
@@ -2516,15 +2516,15 @@ bool Test::HasSameFixtureClass() {
       // Two fixture classes with the same name appear in two different
       // namespaces, which is not allowed. Tell the user how to fix this.
       ADD_FAILURE()
-          << "All tests in the same test suite must use the same test fixture\n"
-          << "class.  However, in test suite "
-          << this_test_info->test_suite_name() << ",\n"
-          << "you defined test " << first_test_name << " and test "
-          << this_test_name << "\n"
+          << "All tests in the same test suite must use the same test fixture\n" 
+          << "class.  However, in test suite " 
+          << this_test_info->test_suite_name() << ",\n" 
+          << "you defined test " << first_test_name << " and test " 
+          << this_test_name << "\n" 
           << "using two different test fixture classes.  This can happen if\n"
           << "the two classes are from different namespaces or translation\n"
           << "units and have the same name.  You should probably rename one\n"
-          << "of the classes to put the tests into different test suites.";
+          << "of the classes to put the tests into different test suites."; 
     }
     return false;
   }
@@ -2557,7 +2557,7 @@ namespace internal {
 static std::string FormatCxxExceptionMessage(const char* description,
                                              const char* location) {
   Message message;
-  if (description != nullptr) {
+  if (description != nullptr) { 
     message << "C++ exception with description \"" << description << "\"";
   } else {
     message << "Unknown C++ exception";
@@ -2641,8 +2641,8 @@ Result HandleExceptionsInMethodIfSupported(
 #if GTEST_HAS_EXCEPTIONS
     try {
       return HandleSehExceptionsInMethodIfSupported(object, method, location);
-    } catch (const AssertionException&) {  // NOLINT
-      // This failure was reported already.
+    } catch (const AssertionException&) {  // NOLINT 
+      // This failure was reported already. 
     } catch (const internal::GoogleTestFailureException&) {  // NOLINT
       // This exception type can only be thrown by a failed Google
       // Test assertion with the intention of letting another testing
@@ -2655,7 +2655,7 @@ Result HandleExceptionsInMethodIfSupported(
     } catch (...) {  // NOLINT
       internal::ReportFailureInUnknownLocation(
           TestPartResult::kFatalFailure,
-          FormatCxxExceptionMessage(nullptr, location));
+          FormatCxxExceptionMessage(nullptr, location)); 
     }
     return static_cast<Result>(0);
 #else
@@ -2675,9 +2675,9 @@ void Test::Run() {
   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
   impl->os_stack_trace_getter()->UponLeavingGTest();
   internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
-  // We will run the test only if SetUp() was successful and didn't call
-  // GTEST_SKIP().
-  if (!HasFatalFailure() && !IsSkipped()) {
+  // We will run the test only if SetUp() was successful and didn't call 
+  // GTEST_SKIP(). 
+  if (!HasFatalFailure() && !IsSkipped()) { 
     impl->os_stack_trace_getter()->UponLeavingGTest();
     internal::HandleExceptionsInMethodIfSupported(
         this, &Test::TestBody, "the test body");
@@ -2691,42 +2691,42 @@ void Test::Run() {
       this, &Test::TearDown, "TearDown()");
 }
 
-// Returns true if and only if the current test has a fatal failure.
+// Returns true if and only if the current test has a fatal failure. 
 bool Test::HasFatalFailure() {
   return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
 }
 
-// Returns true if and only if the current test has a non-fatal failure.
+// Returns true if and only if the current test has a non-fatal failure. 
 bool Test::HasNonfatalFailure() {
   return internal::GetUnitTestImpl()->current_test_result()->
       HasNonfatalFailure();
 }
 
-// Returns true if and only if the current test was skipped.
-bool Test::IsSkipped() {
-  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
-}
-
+// Returns true if and only if the current test was skipped. 
+bool Test::IsSkipped() { 
+  return internal::GetUnitTestImpl()->current_test_result()->Skipped(); 
+} 
+ 
 // class TestInfo
 
 // Constructs a TestInfo object. It assumes ownership of the test factory
 // object.
-TestInfo::TestInfo(const std::string& a_test_suite_name,
-                   const std::string& a_name, const char* a_type_param,
+TestInfo::TestInfo(const std::string& a_test_suite_name, 
+                   const std::string& a_name, const char* a_type_param, 
                    const char* a_value_param,
                    internal::CodeLocation a_code_location,
                    internal::TypeId fixture_class_id,
                    internal::TestFactoryBase* factory)
-    : test_suite_name_(a_test_suite_name),
+    : test_suite_name_(a_test_suite_name), 
       name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
-      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
+      type_param_(a_type_param ? new std::string(a_type_param) : nullptr), 
+      value_param_(a_value_param ? new std::string(a_value_param) : nullptr), 
       location_(a_code_location),
       fixture_class_id_(fixture_class_id),
       should_run_(false),
       is_disabled_(false),
       matches_filter_(false),
-      is_in_another_shard_(false),
+      is_in_another_shard_(false), 
       factory_(factory),
       result_() {}
 
@@ -2740,7 +2740,7 @@ namespace internal {
 //
 // Arguments:
 //
-//   test_suite_name:  name of the test suite
+//   test_suite_name:  name of the test suite 
 //   name:             name of the test
 //   type_param:       the name of the test's type parameter, or NULL if
 //                     this is not a typed or a type-parameterized test.
@@ -2748,39 +2748,39 @@ namespace internal {
 //                     or NULL if this is not a value-parameterized test.
 //   code_location:    code location where the test is defined
 //   fixture_class_id: ID of the test fixture class
-//   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
+//   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 
 //   factory:          pointer to the factory that creates a test object.
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 TestInfo* MakeAndRegisterTestInfo(
-    const char* test_suite_name, const char* name, const char* type_param,
-    const char* value_param, CodeLocation code_location,
-    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
-    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
+    const char* test_suite_name, const char* name, const char* type_param, 
+    const char* value_param, CodeLocation code_location, 
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc, 
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) { 
   TestInfo* const test_info =
-      new TestInfo(test_suite_name, name, type_param, value_param,
+      new TestInfo(test_suite_name, name, type_param, value_param, 
                    code_location, fixture_class_id, factory);
   GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
   return test_info;
 }
 
-void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                CodeLocation code_location) {
+void ReportInvalidTestSuiteType(const char* test_suite_name, 
+                                CodeLocation code_location) { 
   Message errors;
   errors
-      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
-      << "All tests in the same test suite must use the same test fixture\n"
-      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
+      << "Attempted redefinition of test suite " << test_suite_name << ".\n" 
+      << "All tests in the same test suite must use the same test fixture\n" 
+      << "class.  However, in test suite " << test_suite_name << ", you tried\n" 
       << "to define a test using a fixture class different from the one\n"
       << "used earlier. This can happen if the two fixture classes are\n"
       << "from different namespaces and have the same name. You should\n"
       << "probably rename one of the classes to put the tests into different\n"
-      << "test suites.";
+      << "test suites."; 
 
-  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
-                                          code_location.line)
-                    << " " << errors.GetString();
+  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(), 
+                                          code_location.line) 
+                    << " " << errors.GetString(); 
 }
 }  // namespace internal
 
@@ -2789,7 +2789,7 @@ namespace {
 // A predicate that checks the test name of a TestInfo against a known
 // value.
 //
-// This is used for implementation of the TestSuite class only.  We put
+// This is used for implementation of the TestSuite class only.  We put 
 // it in the anonymous namespace to prevent polluting the outer
 // namespace.
 //
@@ -2802,7 +2802,7 @@ class TestNameIs {
   explicit TestNameIs(const char* name)
       : name_(name) {}
 
-  // Returns true if and only if the test name of test_info matches name_.
+  // Returns true if and only if the test name of test_info matches name_. 
   bool operator()(const TestInfo * test_info) const {
     return test_info && test_info->name() == name_;
   }
@@ -2816,12 +2816,12 @@ class TestNameIs {
 namespace internal {
 
 // This method expands all parameterized tests registered with macros TEST_P
-// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
+// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those. 
 // This will be done just once during the program runtime.
 void UnitTestImpl::RegisterParameterizedTests() {
   if (!parameterized_tests_registered_) {
     parameterized_test_registry_.RegisterTests();
-    type_parameterized_test_registry_.CheckForInstantiations();
+    type_parameterized_test_registry_.CheckForInstantiations(); 
     parameterized_tests_registered_ = true;
   }
 }
@@ -2842,8 +2842,8 @@ void TestInfo::Run() {
   // Notifies the unit test event listeners that a test is about to start.
   repeater->OnTestStart(*this);
 
-  result_.set_start_timestamp(internal::GetTimeInMillis());
-  internal::Timer timer;
+  result_.set_start_timestamp(internal::GetTimeInMillis()); 
+  internal::Timer timer; 
 
   impl->os_stack_trace_getter()->UponLeavingGTest();
 
@@ -2852,233 +2852,233 @@ void TestInfo::Run() {
       factory_, &internal::TestFactoryBase::CreateTest,
       "the test fixture's constructor");
 
-  // Runs the test if the constructor didn't generate a fatal failure or invoke
-  // GTEST_SKIP().
-  // Note that the object will not be null
-  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
+  // Runs the test if the constructor didn't generate a fatal failure or invoke 
+  // GTEST_SKIP(). 
+  // Note that the object will not be null 
+  if (!Test::HasFatalFailure() && !Test::IsSkipped()) { 
     // This doesn't throw as all user code that can throw are wrapped into
     // exception handling code.
     test->Run();
   }
 
-  if (test != nullptr) {
-    // Deletes the test object.
-    impl->os_stack_trace_getter()->UponLeavingGTest();
-    internal::HandleExceptionsInMethodIfSupported(
-        test, &Test::DeleteSelf_, "the test fixture's destructor");
-  }
+  if (test != nullptr) { 
+    // Deletes the test object. 
+    impl->os_stack_trace_getter()->UponLeavingGTest(); 
+    internal::HandleExceptionsInMethodIfSupported( 
+        test, &Test::DeleteSelf_, "the test fixture's destructor"); 
+  } 
 
-  result_.set_elapsed_time(timer.Elapsed());
+  result_.set_elapsed_time(timer.Elapsed()); 
 
   // Notifies the unit test event listener that a test has just finished.
   repeater->OnTestEnd(*this);
 
   // Tells UnitTest to stop associating assertion results to this
   // test.
-  impl->set_current_test_info(nullptr);
-}
-
-// Skip and records a skipped test result for this object.
-void TestInfo::Skip() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_info(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Notifies the unit test event listeners that a test is about to start.
-  repeater->OnTestStart(*this);
-
-  const TestPartResult test_part_result =
-      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
-  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
-      test_part_result);
-
-  // Notifies the unit test event listener that a test has just finished.
-  repeater->OnTestEnd(*this);
-  impl->set_current_test_info(nullptr);
-}
-
-// class TestSuite
-
-// Gets the number of successful tests in this test suite.
-int TestSuite::successful_test_count() const {
+  impl->set_current_test_info(nullptr); 
+}
+
+// Skip and records a skipped test result for this object. 
+void TestInfo::Skip() { 
+  if (!should_run_) return; 
+ 
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 
+  impl->set_current_test_info(this); 
+ 
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 
+ 
+  // Notifies the unit test event listeners that a test is about to start. 
+  repeater->OnTestStart(*this); 
+ 
+  const TestPartResult test_part_result = 
+      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), ""); 
+  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult( 
+      test_part_result); 
+ 
+  // Notifies the unit test event listener that a test has just finished. 
+  repeater->OnTestEnd(*this); 
+  impl->set_current_test_info(nullptr); 
+} 
+ 
+// class TestSuite 
+
+// Gets the number of successful tests in this test suite. 
+int TestSuite::successful_test_count() const { 
   return CountIf(test_info_list_, TestPassed);
 }
 
-// Gets the number of successful tests in this test suite.
-int TestSuite::skipped_test_count() const {
-  return CountIf(test_info_list_, TestSkipped);
-}
-
-// Gets the number of failed tests in this test suite.
-int TestSuite::failed_test_count() const {
+// Gets the number of successful tests in this test suite. 
+int TestSuite::skipped_test_count() const { 
+  return CountIf(test_info_list_, TestSkipped); 
+} 
+ 
+// Gets the number of failed tests in this test suite. 
+int TestSuite::failed_test_count() const { 
   return CountIf(test_info_list_, TestFailed);
 }
 
 // Gets the number of disabled tests that will be reported in the XML report.
-int TestSuite::reportable_disabled_test_count() const {
+int TestSuite::reportable_disabled_test_count() const { 
   return CountIf(test_info_list_, TestReportableDisabled);
 }
 
-// Gets the number of disabled tests in this test suite.
-int TestSuite::disabled_test_count() const {
+// Gets the number of disabled tests in this test suite. 
+int TestSuite::disabled_test_count() const { 
   return CountIf(test_info_list_, TestDisabled);
 }
 
 // Gets the number of tests to be printed in the XML report.
-int TestSuite::reportable_test_count() const {
+int TestSuite::reportable_test_count() const { 
   return CountIf(test_info_list_, TestReportable);
 }
 
-// Get the number of tests in this test suite that should run.
-int TestSuite::test_to_run_count() const {
+// Get the number of tests in this test suite that should run. 
+int TestSuite::test_to_run_count() const { 
   return CountIf(test_info_list_, ShouldRunTest);
 }
 
 // Gets the number of all tests.
-int TestSuite::total_test_count() const {
+int TestSuite::total_test_count() const { 
   return static_cast<int>(test_info_list_.size());
 }
 
-// Creates a TestSuite with the given name.
+// Creates a TestSuite with the given name. 
 //
 // Arguments:
 //
-//   a_name:       name of the test suite
-//   a_type_param: the name of the test suite's type parameter, or NULL if
-//                 this is not a typed or a type-parameterized test suite.
-//   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::TestSuite(const char* a_name, const char* a_type_param,
-                     internal::SetUpTestSuiteFunc set_up_tc,
-                     internal::TearDownTestSuiteFunc tear_down_tc)
+//   a_name:       name of the test suite 
+//   a_type_param: the name of the test suite's type parameter, or NULL if 
+//                 this is not a typed or a type-parameterized test suite. 
+//   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::TestSuite(const char* a_name, const char* a_type_param, 
+                     internal::SetUpTestSuiteFunc set_up_tc, 
+                     internal::TearDownTestSuiteFunc tear_down_tc) 
     : name_(a_name),
-      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
+      type_param_(a_type_param ? new std::string(a_type_param) : nullptr), 
       set_up_tc_(set_up_tc),
       tear_down_tc_(tear_down_tc),
       should_run_(false),
-      start_timestamp_(0),
-      elapsed_time_(0) {}
+      start_timestamp_(0), 
+      elapsed_time_(0) {} 
 
-// Destructor of TestSuite.
-TestSuite::~TestSuite() {
+// Destructor of TestSuite. 
+TestSuite::~TestSuite() { 
   // Deletes every Test in the collection.
   ForEach(test_info_list_, internal::Delete<TestInfo>);
 }
 
 // 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* TestSuite::GetTestInfo(int i) const {
+const TestInfo* TestSuite::GetTestInfo(int i) const { 
   const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)]; 
 }
 
 // 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* TestSuite::GetMutableTestInfo(int i) {
+TestInfo* TestSuite::GetMutableTestInfo(int i) { 
   const int index = GetElementOr(test_indices_, i, -1);
-  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)]; 
 }
 
-// Adds a test to this test suite.  Will delete the test upon
-// destruction of the TestSuite object.
-void TestSuite::AddTestInfo(TestInfo* test_info) {
+// Adds a test to this test suite.  Will delete the test upon 
+// destruction of the TestSuite object. 
+void TestSuite::AddTestInfo(TestInfo* test_info) { 
   test_info_list_.push_back(test_info);
   test_indices_.push_back(static_cast<int>(test_indices_.size()));
 }
 
-// Runs every test in this TestSuite.
-void TestSuite::Run() {
+// Runs every test in this TestSuite. 
+void TestSuite::Run() { 
   if (!should_run_) return;
 
   internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_suite(this);
+  impl->set_current_test_suite(this); 
 
   TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 
-  // Call both legacy and the new API
-  repeater->OnTestSuiteStart(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  // Call both legacy and the new API 
+  repeater->OnTestSuiteStart(*this); 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
   repeater->OnTestCaseStart(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
   impl->os_stack_trace_getter()->UponLeavingGTest();
   internal::HandleExceptionsInMethodIfSupported(
-      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
+      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()"); 
 
-  start_timestamp_ = internal::GetTimeInMillis();
-  internal::Timer timer;
+  start_timestamp_ = internal::GetTimeInMillis(); 
+  internal::Timer timer; 
   for (int i = 0; i < total_test_count(); i++) {
     GetMutableTestInfo(i)->Run();
-    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
-      for (int j = i + 1; j < total_test_count(); j++) {
-        GetMutableTestInfo(j)->Skip();
-      }
-      break;
-    }
+    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) { 
+      for (int j = i + 1; j < total_test_count(); j++) { 
+        GetMutableTestInfo(j)->Skip(); 
+      } 
+      break; 
+    } 
   }
-  elapsed_time_ = timer.Elapsed();
+  elapsed_time_ = timer.Elapsed(); 
 
   impl->os_stack_trace_getter()->UponLeavingGTest();
   internal::HandleExceptionsInMethodIfSupported(
-      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
+      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()"); 
 
-  // Call both legacy and the new API
-  repeater->OnTestSuiteEnd(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  // Call both legacy and the new API 
+  repeater->OnTestSuiteEnd(*this); 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
   repeater->OnTestCaseEnd(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  impl->set_current_test_suite(nullptr);
-}
-
-// Skips all tests under this TestSuite.
-void TestSuite::Skip() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_suite(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteStart(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  repeater->OnTestCaseStart(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Skip();
-  }
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteEnd(*this);
-  // Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  repeater->OnTestCaseEnd(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
-  impl->set_current_test_suite(nullptr);
-}
-
-// Clears the results of all tests in this test suite.
-void TestSuite::ClearResult() {
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+  impl->set_current_test_suite(nullptr); 
+}
+
+// Skips all tests under this TestSuite. 
+void TestSuite::Skip() { 
+  if (!should_run_) return; 
+ 
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 
+  impl->set_current_test_suite(this); 
+ 
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 
+ 
+  // Call both legacy and the new API 
+  repeater->OnTestSuiteStart(*this); 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  repeater->OnTestCaseStart(*this); 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+  for (int i = 0; i < total_test_count(); i++) { 
+    GetMutableTestInfo(i)->Skip(); 
+  } 
+ 
+  // Call both legacy and the new API 
+  repeater->OnTestSuiteEnd(*this); 
+  // Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  repeater->OnTestCaseEnd(*this); 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
+  impl->set_current_test_suite(nullptr); 
+} 
+ 
+// Clears the results of all tests in this test suite. 
+void TestSuite::ClearResult() { 
   ad_hoc_test_result_.Clear();
   ForEach(test_info_list_, TestInfo::ClearTestResult);
 }
 
-// Shuffles the tests in this test suite.
-void TestSuite::ShuffleTests(internal::Random* random) {
+// Shuffles the tests in this test suite. 
+void TestSuite::ShuffleTests(internal::Random* random) { 
   Shuffle(random, &test_indices_);
 }
 
 // Restores the test order to before the first shuffle.
-void TestSuite::UnshuffleTests() {
+void TestSuite::UnshuffleTests() { 
   for (size_t i = 0; i < test_indices_.size(); i++) {
     test_indices_[i] = static_cast<int>(i);
   }
@@ -3101,9 +3101,9 @@ static std::string FormatTestCount(int test_count) {
   return FormatCountableNoun(test_count, "test", "tests");
 }
 
-// Formats the count of test suites.
-static std::string FormatTestSuiteCount(int test_suite_count) {
-  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
+// Formats the count of test suites. 
+static std::string FormatTestSuiteCount(int test_suite_count) { 
+  return FormatCountableNoun(test_suite_count, "test suite", "test suites"); 
 }
 
 // Converts a TestPartResult::Type enum to human-friendly string
@@ -3112,8 +3112,8 @@ static std::string FormatTestSuiteCount(int test_suite_count) {
 // between the two when viewing the test result.
 static const char * TestPartResultTypeToString(TestPartResult::Type type) {
   switch (type) {
-    case TestPartResult::kSkip:
-      return "Skipped\n";
+    case TestPartResult::kSkip: 
+      return "Skipped\n"; 
     case TestPartResult::kSuccess:
       return "Success";
 
@@ -3130,9 +3130,9 @@ static const char * TestPartResultTypeToString(TestPartResult::Type type) {
 }
 
 namespace internal {
-namespace {
-enum class GTestColor { kDefault, kRed, kGreen, kYellow };
-}  // namespace
+namespace { 
+enum class GTestColor { kDefault, kRed, kGreen, kYellow }; 
+}  // namespace 
 
 // Prints a TestPartResult to an std::string.
 static std::string PrintTestPartResultToString(
@@ -3165,77 +3165,77 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
 
 // class PrettyUnitTestResultPrinter
 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW 
 
 // Returns the character attribute for the given color.
-static WORD GetColorAttribute(GTestColor color) {
+static WORD GetColorAttribute(GTestColor color) { 
   switch (color) {
-    case GTestColor::kRed:
-      return FOREGROUND_RED;
-    case GTestColor::kGreen:
-      return FOREGROUND_GREEN;
-    case GTestColor::kYellow:
-      return FOREGROUND_RED | FOREGROUND_GREEN;
+    case GTestColor::kRed: 
+      return FOREGROUND_RED; 
+    case GTestColor::kGreen: 
+      return FOREGROUND_GREEN; 
+    case GTestColor::kYellow: 
+      return FOREGROUND_RED | FOREGROUND_GREEN; 
     default:           return 0;
   }
 }
 
-static int GetBitOffset(WORD color_mask) {
-  if (color_mask == 0) return 0;
-
-  int bitOffset = 0;
-  while ((color_mask & 1) == 0) {
-    color_mask >>= 1;
-    ++bitOffset;
-  }
-  return bitOffset;
-}
-
-static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
-  // Let's reuse the BG
-  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
-                                      BACKGROUND_RED | BACKGROUND_INTENSITY;
-  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
-                                      FOREGROUND_RED | FOREGROUND_INTENSITY;
-  const WORD existing_bg = old_color_attrs & background_mask;
-
-  WORD new_color =
-      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
-  static const int bg_bitOffset = GetBitOffset(background_mask);
-  static const int fg_bitOffset = GetBitOffset(foreground_mask);
-
-  if (((new_color & background_mask) >> bg_bitOffset) ==
-      ((new_color & foreground_mask) >> fg_bitOffset)) {
-    new_color ^= FOREGROUND_INTENSITY;  // invert intensity
-  }
-  return new_color;
-}
-
+static int GetBitOffset(WORD color_mask) { 
+  if (color_mask == 0) return 0; 
+ 
+  int bitOffset = 0; 
+  while ((color_mask & 1) == 0) { 
+    color_mask >>= 1; 
+    ++bitOffset; 
+  } 
+  return bitOffset; 
+} 
+ 
+static WORD GetNewColor(GTestColor color, WORD old_color_attrs) { 
+  // Let's reuse the BG 
+  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN | 
+                                      BACKGROUND_RED | BACKGROUND_INTENSITY; 
+  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN | 
+                                      FOREGROUND_RED | FOREGROUND_INTENSITY; 
+  const WORD existing_bg = old_color_attrs & background_mask; 
+ 
+  WORD new_color = 
+      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY; 
+  static const int bg_bitOffset = GetBitOffset(background_mask); 
+  static const int fg_bitOffset = GetBitOffset(foreground_mask); 
+ 
+  if (((new_color & background_mask) >> bg_bitOffset) == 
+      ((new_color & foreground_mask) >> fg_bitOffset)) { 
+    new_color ^= FOREGROUND_INTENSITY;  // invert intensity 
+  } 
+  return new_color; 
+} 
+ 
 #else
 
-// Returns the ANSI color code for the given color. GTestColor::kDefault is
+// Returns the ANSI color code for the given color. GTestColor::kDefault is 
 // an invalid input.
-static const char* GetAnsiColorCode(GTestColor color) {
+static const char* GetAnsiColorCode(GTestColor color) { 
   switch (color) {
-    case GTestColor::kRed:
-      return "1";
-    case GTestColor::kGreen:
-      return "2";
-    case GTestColor::kYellow:
-      return "3";
-    default:
-      return nullptr;
-  }
+    case GTestColor::kRed: 
+      return "1"; 
+    case GTestColor::kGreen: 
+      return "2"; 
+    case GTestColor::kYellow: 
+      return "3"; 
+    default: 
+      return nullptr; 
+  } 
 }
 
 #endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
 
-// Returns true if and only if Google Test should use colors in the output.
+// Returns true if and only if Google Test should use colors in the output. 
 bool ShouldUseColor(bool stdout_is_tty) {
   const char* const gtest_color = GTEST_FLAG(color).c_str();
 
   if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
-#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW 
     // On Windows the TERM variable is usually not set, but the
     // console there does support colors.
     return stdout_is_tty;
@@ -3271,20 +3271,20 @@ bool ShouldUseColor(bool stdout_is_tty) {
 // cannot simply emit special characters and have the terminal change colors.
 // This routine must actually emit the characters rather than return a string
 // that would be colored when printed, as can be done on Linux.
-
-GTEST_ATTRIBUTE_PRINTF_(2, 3)
-static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
+ 
+GTEST_ATTRIBUTE_PRINTF_(2, 3) 
+static void ColoredPrintf(GTestColor color, const char *fmt, ...) { 
   va_list args;
   va_start(args, fmt);
 
-#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
-    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \ 
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM) 
   const bool use_color = AlwaysFalse();
 #else
   static const bool in_color_mode =
       ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
-  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
-#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
+  const bool use_color = in_color_mode && (color != GTestColor::kDefault); 
+#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS 
 
   if (!use_color) {
     vprintf(fmt, args);
@@ -3293,21 +3293,21 @@ static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
   }
 
 #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
-    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW 
   const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 
   // Gets the current text color.
   CONSOLE_SCREEN_BUFFER_INFO buffer_info;
   GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
   const WORD old_color_attrs = buffer_info.wAttributes;
-  const WORD new_color = GetNewColor(color, old_color_attrs);
+  const WORD new_color = GetNewColor(color, old_color_attrs); 
 
   // We need to flush the stream buffers into the console before each
   // SetConsoleTextAttribute call lest it affect the text that is already
   // printed but has not yet reached the console.
   fflush(stdout);
-  SetConsoleTextAttribute(stdout_handle, new_color);
-
+  SetConsoleTextAttribute(stdout_handle, new_color); 
+ 
   vprintf(fmt, args);
 
   fflush(stdout);
@@ -3321,22 +3321,22 @@ static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
   va_end(args);
 }
 
-// Text printed in Google Test's text output and --gtest_list_tests
+// Text printed in Google Test's text output and --gtest_list_tests 
 // output to label the type parameter and value parameter for a test.
 static const char kTypeParamLabel[] = "TypeParam";
 static const char kValueParamLabel[] = "GetParam()";
 
-static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
+static void PrintFullTestCommentIfPresent(const TestInfo& test_info) { 
   const char* const type_param = test_info.type_param();
   const char* const value_param = test_info.value_param();
 
-  if (type_param != nullptr || value_param != nullptr) {
+  if (type_param != nullptr || value_param != nullptr) { 
     printf(", where ");
-    if (type_param != nullptr) {
+    if (type_param != nullptr) { 
       printf("%s = %s", kTypeParamLabel, type_param);
-      if (value_param != nullptr) printf(" and ");
+      if (value_param != nullptr) printf(" and "); 
     }
-    if (value_param != nullptr) {
+    if (value_param != nullptr) { 
       printf("%s = %s", kValueParamLabel, value_param);
     }
   }
@@ -3348,40 +3348,40 @@ static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
 class PrettyUnitTestResultPrinter : public TestEventListener {
  public:
   PrettyUnitTestResultPrinter() {}
-  static void PrintTestName(const char* test_suite, const char* test) {
-    printf("%s.%s", test_suite, test);
+  static void PrintTestName(const char* test_suite, const char* test) { 
+    printf("%s.%s", test_suite, test); 
   }
 
   // The following methods override what's in the TestEventListener class.
-  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 {}
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseStart(const TestCase& test_case) override;
-#else
-  void OnTestSuiteStart(const TestSuite& test_suite) override;
-#endif  // OnTestCaseStart
-
-  void OnTestStart(const TestInfo& test_info) override;
-
-  void OnTestPartResult(const TestPartResult& result) override;
-  void OnTestEnd(const TestInfo& test_info) override;
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseEnd(const TestCase& test_case) override;
-#else
-  void OnTestSuiteEnd(const TestSuite& test_suite) 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 {}
-
+  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 {} 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseStart(const TestCase& test_case) override; 
+#else 
+  void OnTestSuiteStart(const TestSuite& test_suite) override; 
+#endif  // OnTestCaseStart 
+
+  void OnTestStart(const TestInfo& test_info) override; 
+ 
+  void OnTestPartResult(const TestPartResult& result) override; 
+  void OnTestEnd(const TestInfo& test_info) override; 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseEnd(const TestCase& test_case) override; 
+#else 
+  void OnTestSuiteEnd(const TestSuite& test_suite) 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 {} 
+ 
  private:
   static void PrintFailedTests(const UnitTest& unit_test);
-  static void PrintFailedTestSuites(const UnitTest& unit_test);
-  static void PrintSkippedTests(const UnitTest& unit_test);
+  static void PrintFailedTestSuites(const UnitTest& unit_test); 
+  static void PrintSkippedTests(const UnitTest& unit_test); 
 };
 
   // Fired before each iteration of tests starts.
@@ -3395,69 +3395,69 @@ void PrettyUnitTestResultPrinter::OnTestIterationStart(
   // Prints the filter if it's not *.  This reminds the user that some
   // tests may be skipped.
   if (!String::CStringEquals(filter, kUniversalFilter)) {
-    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
-                  filter);
+    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_, 
+                  filter); 
   }
 
   if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
-    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
-    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
+    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); 
+    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n", 
                   static_cast<int>(shard_index) + 1,
                   internal::posix::GetEnv(kTestTotalShards));
   }
 
   if (GTEST_FLAG(shuffle)) {
-    ColoredPrintf(GTestColor::kYellow,
+    ColoredPrintf(GTestColor::kYellow, 
                   "Note: Randomizing tests' orders with a seed of %d .\n",
                   unit_test.random_seed());
   }
 
-  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  ColoredPrintf(GTestColor::kGreen, "[==========] "); 
   printf("Running %s from %s.\n",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); 
   fflush(stdout);
 }
 
 void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
     const UnitTest& /*unit_test*/) {
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
   printf("Global test environment set-up.\n");
   fflush(stdout);
 }
 
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
   const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
   printf("%s from %s", counts.c_str(), test_case.name());
-  if (test_case.type_param() == nullptr) {
+  if (test_case.type_param() == nullptr) { 
     printf("\n");
   } else {
     printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
   }
   fflush(stdout);
 }
-#else
-void PrettyUnitTestResultPrinter::OnTestSuiteStart(
-    const TestSuite& test_suite) {
-  const std::string counts =
-      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
-  printf("%s from %s", counts.c_str(), test_suite.name());
-  if (test_suite.type_param() == nullptr) {
-    printf("\n");
-  } else {
-    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
-  }
-  fflush(stdout);
-}
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#else 
+void PrettyUnitTestResultPrinter::OnTestSuiteStart( 
+    const TestSuite& test_suite) { 
+  const std::string counts = 
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests"); 
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
+  printf("%s from %s", counts.c_str(), test_suite.name()); 
+  if (test_suite.type_param() == nullptr) { 
+    printf("\n"); 
+  } else { 
+    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param()); 
+  } 
+  fflush(stdout); 
+} 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 
 void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
-  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
-  PrintTestName(test_info.test_suite_name(), test_info.name());
+  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] "); 
+  PrintTestName(test_info.test_suite_name(), test_info.name()); 
   printf("\n");
   fflush(stdout);
 }
@@ -3465,27 +3465,27 @@ void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
 // Called after an assertion failure.
 void PrettyUnitTestResultPrinter::OnTestPartResult(
     const TestPartResult& result) {
-  switch (result.type()) {
-    // If the test part succeeded, we don't need to do anything.
-    case TestPartResult::kSuccess:
-      return;
-    default:
-      // Print failure message from the assertion
-      // (e.g. expected this and got that).
-      PrintTestPartResult(result);
-      fflush(stdout);
-  }
+  switch (result.type()) { 
+    // If the test part succeeded, we don't need to do anything. 
+    case TestPartResult::kSuccess: 
+      return; 
+    default: 
+      // Print failure message from the assertion 
+      // (e.g. expected this and got that). 
+      PrintTestPartResult(result); 
+      fflush(stdout); 
+  } 
 }
 
 void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
   if (test_info.result()->Passed()) {
-    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
-  } else if (test_info.result()->Skipped()) {
-    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    ColoredPrintf(GTestColor::kGreen, "[       OK ] "); 
+  } else if (test_info.result()->Skipped()) { 
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] "); 
   } else {
-    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] "); 
   }
-  PrintTestName(test_info.test_suite_name(), test_info.name());
+  PrintTestName(test_info.test_suite_name(), test_info.name()); 
   if (test_info.result()->Failed())
     PrintFullTestCommentIfPresent(test_info);
 
@@ -3498,33 +3498,33 @@ void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
   fflush(stdout);
 }
 
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
   if (!GTEST_FLAG(print_time)) return;
 
   const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
-  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(), 
          internal::StreamableToString(test_case.elapsed_time()).c_str());
   fflush(stdout);
 }
-#else
-void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
-  if (!GTEST_FLAG(print_time)) return;
-
-  const std::string counts =
-      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
-  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
-         internal::StreamableToString(test_suite.elapsed_time()).c_str());
-  fflush(stdout);
-}
-#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-
+#else 
+void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) { 
+  if (!GTEST_FLAG(print_time)) return; 
+
+  const std::string counts = 
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests"); 
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(), 
+         internal::StreamableToString(test_suite.elapsed_time()).c_str()); 
+  fflush(stdout); 
+} 
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+ 
 void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
     const UnitTest& /*unit_test*/) {
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(GTestColor::kGreen, "[----------] "); 
   printf("Global test environment tear-down\n");
   fflush(stdout);
 }
@@ -3532,108 +3532,108 @@ void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
 // Internal helper for printing the list of failed tests.
 void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
   const int failed_test_count = unit_test.failed_test_count();
-  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
-  printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] "); 
+  printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); 
 
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
-    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { 
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i); 
+    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) { 
       continue;
     }
-    for (int j = 0; j < test_suite.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_suite.GetTestInfo(j);
-      if (!test_info.should_run() || !test_info.result()->Failed()) {
+    for (int j = 0; j < test_suite.total_test_count(); ++j) { 
+      const TestInfo& test_info = *test_suite.GetTestInfo(j); 
+      if (!test_info.should_run() || !test_info.result()->Failed()) { 
         continue;
       }
-      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
-      printf("%s.%s", test_suite.name(), test_info.name());
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] "); 
+      printf("%s.%s", test_suite.name(), test_info.name()); 
       PrintFullTestCommentIfPresent(test_info);
       printf("\n");
     }
   }
-  printf("\n%2d FAILED %s\n", failed_test_count,
-         failed_test_count == 1 ? "TEST" : "TESTS");
-}
-
-// Internal helper for printing the list of test suite failures not covered by
-// PrintFailedTests.
-void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
-    const UnitTest& unit_test) {
-  int suite_failure_count = 0;
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
-    if (!test_suite.should_run()) {
-      continue;
-    }
-    if (test_suite.ad_hoc_test_result().Failed()) {
-      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
-      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
-      ++suite_failure_count;
-    }
-  }
-  if (suite_failure_count > 0) {
-    printf("\n%2d FAILED TEST %s\n", suite_failure_count,
-           suite_failure_count == 1 ? "SUITE" : "SUITES");
-  }
-}
-
-// Internal helper for printing the list of skipped tests.
-void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
-  const int skipped_test_count = unit_test.skipped_test_count();
-  if (skipped_test_count == 0) {
-    return;
-  }
-
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
-    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
-      continue;
-    }
-    for (int j = 0; j < test_suite.total_test_count(); ++j) {
-      const TestInfo& test_info = *test_suite.GetTestInfo(j);
-      if (!test_info.should_run() || !test_info.result()->Skipped()) {
-        continue;
-      }
-      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
-      printf("%s.%s", test_suite.name(), test_info.name());
-      printf("\n");
-    }
-  }
-}
-
+  printf("\n%2d FAILED %s\n", failed_test_count, 
+         failed_test_count == 1 ? "TEST" : "TESTS"); 
+}
+
+// Internal helper for printing the list of test suite failures not covered by 
+// PrintFailedTests. 
+void PrettyUnitTestResultPrinter::PrintFailedTestSuites( 
+    const UnitTest& unit_test) { 
+  int suite_failure_count = 0; 
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { 
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i); 
+    if (!test_suite.should_run()) { 
+      continue; 
+    } 
+    if (test_suite.ad_hoc_test_result().Failed()) { 
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] "); 
+      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name()); 
+      ++suite_failure_count; 
+    } 
+  } 
+  if (suite_failure_count > 0) { 
+    printf("\n%2d FAILED TEST %s\n", suite_failure_count, 
+           suite_failure_count == 1 ? "SUITE" : "SUITES"); 
+  } 
+} 
+ 
+// Internal helper for printing the list of skipped tests. 
+void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) { 
+  const int skipped_test_count = unit_test.skipped_test_count(); 
+  if (skipped_test_count == 0) { 
+    return; 
+  } 
+ 
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { 
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i); 
+    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) { 
+      continue; 
+    } 
+    for (int j = 0; j < test_suite.total_test_count(); ++j) { 
+      const TestInfo& test_info = *test_suite.GetTestInfo(j); 
+      if (!test_info.should_run() || !test_info.result()->Skipped()) { 
+        continue; 
+      } 
+      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] "); 
+      printf("%s.%s", test_suite.name(), test_info.name()); 
+      printf("\n"); 
+    } 
+  } 
+} 
+ 
 void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                      int /*iteration*/) {
-  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  ColoredPrintf(GTestColor::kGreen, "[==========] "); 
   printf("%s from %s ran.",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); 
   if (GTEST_FLAG(print_time)) {
     printf(" (%s ms total)",
            internal::StreamableToString(unit_test.elapsed_time()).c_str());
   }
   printf("\n");
-  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] "); 
   printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
 
-  const int skipped_test_count = unit_test.skipped_test_count();
-  if (skipped_test_count > 0) {
-    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
-    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
-    PrintSkippedTests(unit_test);
-  }
-
+  const int skipped_test_count = unit_test.skipped_test_count(); 
+  if (skipped_test_count > 0) { 
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] "); 
+    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str()); 
+    PrintSkippedTests(unit_test); 
+  } 
+ 
   if (!unit_test.Passed()) {
     PrintFailedTests(unit_test);
-    PrintFailedTestSuites(unit_test);
+    PrintFailedTestSuites(unit_test); 
   }
 
   int num_disabled = unit_test.reportable_disabled_test_count();
   if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
-    if (unit_test.Passed()) {
+    if (unit_test.Passed()) { 
       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
     }
-    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
-                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n", 
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS"); 
   }
   // Ensure that Google Test output is printed before, e.g., heapchecker output.
   fflush(stdout);
@@ -3641,117 +3641,117 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
 
 // End PrettyUnitTestResultPrinter
 
-// This class implements the TestEventListener interface.
-//
-// Class BriefUnitTestResultPrinter is copyable.
-class BriefUnitTestResultPrinter : public TestEventListener {
- public:
-  BriefUnitTestResultPrinter() {}
-  static void PrintTestName(const char* test_suite, const char* test) {
-    printf("%s.%s", test_suite, test);
-  }
-
-  // The following methods override what's in the TestEventListener class.
-  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 {}
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
-#else
-  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
-#endif  // OnTestCaseStart
-
-  void OnTestStart(const TestInfo& /*test_info*/) override {}
-
-  void OnTestPartResult(const TestPartResult& result) override;
-  void OnTestEnd(const TestInfo& test_info) override;
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
-#else
-  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) 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 {}
-};
-
-// Called after an assertion failure.
-void BriefUnitTestResultPrinter::OnTestPartResult(
-    const TestPartResult& result) {
-  switch (result.type()) {
-    // If the test part succeeded, we don't need to do anything.
-    case TestPartResult::kSuccess:
-      return;
-    default:
-      // Print failure message from the assertion
-      // (e.g. expected this and got that).
-      PrintTestPartResult(result);
-      fflush(stdout);
-  }
-}
-
-void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
-  if (test_info.result()->Failed()) {
-    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
-    PrintTestName(test_info.test_suite_name(), test_info.name());
-    PrintFullTestCommentIfPresent(test_info);
-
-    if (GTEST_FLAG(print_time)) {
-      printf(" (%s ms)\n",
-             internal::StreamableToString(test_info.result()->elapsed_time())
-                 .c_str());
-    } else {
-      printf("\n");
-    }
-    fflush(stdout);
-  }
-}
-
-void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                    int /*iteration*/) {
-  ColoredPrintf(GTestColor::kGreen, "[==========] ");
-  printf("%s from %s ran.",
-         FormatTestCount(unit_test.test_to_run_count()).c_str(),
-         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
-  if (GTEST_FLAG(print_time)) {
-    printf(" (%s ms total)",
-           internal::StreamableToString(unit_test.elapsed_time()).c_str());
-  }
-  printf("\n");
-  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
-  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
-
-  const int skipped_test_count = unit_test.skipped_test_count();
-  if (skipped_test_count > 0) {
-    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
-    printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
-  }
-
-  int num_disabled = unit_test.reportable_disabled_test_count();
-  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
-    if (unit_test.Passed()) {
-      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
-    }
-    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
-                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
-  }
-  // Ensure that Google Test output is printed before, e.g., heapchecker output.
-  fflush(stdout);
-}
-
-// End BriefUnitTestResultPrinter
-
+// This class implements the TestEventListener interface. 
+// 
+// Class BriefUnitTestResultPrinter is copyable. 
+class BriefUnitTestResultPrinter : public TestEventListener { 
+ public: 
+  BriefUnitTestResultPrinter() {} 
+  static void PrintTestName(const char* test_suite, const char* test) { 
+    printf("%s.%s", test_suite, test); 
+  } 
+ 
+  // The following methods override what's in the TestEventListener class. 
+  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 {} 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {} 
+#else 
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {} 
+#endif  // OnTestCaseStart 
+ 
+  void OnTestStart(const TestInfo& /*test_info*/) override {} 
+ 
+  void OnTestPartResult(const TestPartResult& result) override; 
+  void OnTestEnd(const TestInfo& test_info) override; 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {} 
+#else 
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) 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 {} 
+}; 
+ 
+// Called after an assertion failure. 
+void BriefUnitTestResultPrinter::OnTestPartResult( 
+    const TestPartResult& result) { 
+  switch (result.type()) { 
+    // If the test part succeeded, we don't need to do anything. 
+    case TestPartResult::kSuccess: 
+      return; 
+    default: 
+      // Print failure message from the assertion 
+      // (e.g. expected this and got that). 
+      PrintTestPartResult(result); 
+      fflush(stdout); 
+  } 
+} 
+ 
+void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { 
+  if (test_info.result()->Failed()) { 
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] "); 
+    PrintTestName(test_info.test_suite_name(), test_info.name()); 
+    PrintFullTestCommentIfPresent(test_info); 
+ 
+    if (GTEST_FLAG(print_time)) { 
+      printf(" (%s ms)\n", 
+             internal::StreamableToString(test_info.result()->elapsed_time()) 
+                 .c_str()); 
+    } else { 
+      printf("\n"); 
+    } 
+    fflush(stdout); 
+  } 
+} 
+ 
+void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 
+                                                    int /*iteration*/) { 
+  ColoredPrintf(GTestColor::kGreen, "[==========] "); 
+  printf("%s from %s ran.", 
+         FormatTestCount(unit_test.test_to_run_count()).c_str(), 
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); 
+  if (GTEST_FLAG(print_time)) { 
+    printf(" (%s ms total)", 
+           internal::StreamableToString(unit_test.elapsed_time()).c_str()); 
+  } 
+  printf("\n"); 
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] "); 
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); 
+ 
+  const int skipped_test_count = unit_test.skipped_test_count(); 
+  if (skipped_test_count > 0) { 
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] "); 
+    printf("%s.\n", FormatTestCount(skipped_test_count).c_str()); 
+  } 
+ 
+  int num_disabled = unit_test.reportable_disabled_test_count(); 
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { 
+    if (unit_test.Passed()) { 
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed. 
+    } 
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n", 
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS"); 
+  } 
+  // Ensure that Google Test output is printed before, e.g., heapchecker output. 
+  fflush(stdout); 
+} 
+ 
+// End BriefUnitTestResultPrinter 
+ 
 // class TestEventRepeater
 //
 // This class forwards events to other event listeners.
 class TestEventRepeater : public TestEventListener {
  public:
   TestEventRepeater() : forwarding_enabled_(true) {}
-  ~TestEventRepeater() override;
+  ~TestEventRepeater() override; 
   void Append(TestEventListener *listener);
   TestEventListener* Release(TestEventListener* listener);
 
@@ -3760,27 +3760,27 @@ class TestEventRepeater : public TestEventListener {
   bool forwarding_enabled() const { return forwarding_enabled_; }
   void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
 
-  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;
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseStart(const TestSuite& parameter) override;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestSuiteStart(const TestSuite& parameter) override;
-  void OnTestStart(const TestInfo& test_info) override;
-  void OnTestPartResult(const TestPartResult& result) override;
-  void OnTestEnd(const TestInfo& test_info) override;
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestCaseEnd(const TestCase& parameter) override;
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  void OnTestSuiteEnd(const TestSuite& parameter) override;
-  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;
+  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; 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseStart(const TestSuite& parameter) override; 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestSuiteStart(const TestSuite& parameter) override; 
+  void OnTestStart(const TestInfo& test_info) override; 
+  void OnTestPartResult(const TestPartResult& result) override; 
+  void OnTestEnd(const TestInfo& test_info) override; 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestCaseEnd(const TestCase& parameter) override; 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+  void OnTestSuiteEnd(const TestSuite& parameter) override; 
+  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; 
 
  private:
   // Controls whether events will be forwarded to listeners_. Set to false
@@ -3803,12 +3803,12 @@ void TestEventRepeater::Append(TestEventListener *listener) {
 TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
   for (size_t i = 0; i < listeners_.size(); ++i) {
     if (listeners_[i] == listener) {
-      listeners_.erase(listeners_.begin() + static_cast<int>(i));
+      listeners_.erase(listeners_.begin() + static_cast<int>(i)); 
       return listener;
     }
   }
 
-  return nullptr;
+  return nullptr; 
 }
 
 // Since most methods are very similar, use macros to reduce boilerplate.
@@ -3823,33 +3823,33 @@ void TestEventRepeater::Name(const Type& parameter) { \
 }
 // This defines a member that forwards the call to all listeners in reverse
 // order.
-#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \
-  void TestEventRepeater::Name(const Type& parameter) { \
-    if (forwarding_enabled_) {                          \
-      for (size_t i = listeners_.size(); i != 0; i--) { \
-        listeners_[i - 1]->Name(parameter);             \
-      }                                                 \
-    }                                                   \
-  }
+#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \ 
+  void TestEventRepeater::Name(const Type& parameter) { \ 
+    if (forwarding_enabled_) {                          \ 
+      for (size_t i = listeners_.size(); i != 0; i--) { \ 
+        listeners_[i - 1]->Name(parameter);             \ 
+      }                                                 \ 
+    }                                                   \ 
+  } 
 
 GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
 GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite) 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite) 
 GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
 GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
 GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
 GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
 GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite) 
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite) 
 GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
 
 #undef GTEST_REPEATER_METHOD_
@@ -3867,8 +3867,8 @@ void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
 void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
                                            int iteration) {
   if (forwarding_enabled_) {
-    for (size_t i = listeners_.size(); i > 0; i--) {
-      listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
+    for (size_t i = listeners_.size(); i > 0; i--) { 
+      listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration); 
     }
   }
 }
@@ -3880,13 +3880,13 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
  public:
   explicit XmlUnitTestResultPrinter(const char* output_file);
 
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
-
-  // Prints an XML summary of all unit tests.
-  static void PrintXmlTestsList(std::ostream* stream,
-                                const std::vector<TestSuite*>& test_suites);
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; 
+  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites); 
 
+  // Prints an XML summary of all unit tests. 
+  static void PrintXmlTestsList(std::ostream* stream, 
+                                const std::vector<TestSuite*>& test_suites); 
+ 
  private:
   // Is c a whitespace character that is normalized to a space character
   // when it appears in an XML attribute value?
@@ -3928,24 +3928,24 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
   // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
   static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
 
-  // Streams a test suite XML stanza containing the given test result.
-  //
-  // Requires: result.Failed()
-  static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
-                                              const TestResult& result);
-
-  // Streams an XML representation of a TestResult object.
-  static void OutputXmlTestResult(::std::ostream* stream,
-                                  const TestResult& result);
-
+  // Streams a test suite XML stanza containing the given test result. 
+  // 
+  // Requires: result.Failed() 
+  static void OutputXmlTestSuiteForTestResult(::std::ostream* stream, 
+                                              const TestResult& result); 
+ 
+  // Streams an XML representation of a TestResult object. 
+  static void OutputXmlTestResult(::std::ostream* stream, 
+                                  const TestResult& result); 
+ 
   // Streams an XML representation of a TestInfo object.
   static void OutputXmlTestInfo(::std::ostream* stream,
-                                const char* test_suite_name,
+                                const char* test_suite_name, 
                                 const TestInfo& test_info);
 
-  // Prints an XML representation of a TestSuite object
-  static void PrintXmlTestSuite(::std::ostream* stream,
-                                const TestSuite& test_suite);
+  // Prints an XML representation of a TestSuite object 
+  static void PrintXmlTestSuite(::std::ostream* stream, 
+                                const TestSuite& test_suite); 
 
   // Prints an XML summary of unit_test to output stream out.
   static void PrintXmlUnitTest(::std::ostream* stream,
@@ -3957,11 +3957,11 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
   // to delimit this attribute from prior attributes.
   static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
 
-  // Streams an XML representation of the test properties of a TestResult
-  // object.
-  static void OutputXmlTestProperties(std::ostream* stream,
-                                      const TestResult& result);
-
+  // Streams an XML representation of the test properties of a TestResult 
+  // object. 
+  static void OutputXmlTestProperties(std::ostream* stream, 
+                                      const TestResult& result); 
+ 
   // The output file.
   const std::string output_file_;
 
@@ -3971,30 +3971,30 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
 // Creates a new XmlUnitTestResultPrinter.
 XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
     : output_file_(output_file) {
-  if (output_file_.empty()) {
-    GTEST_LOG_(FATAL) << "XML output file may not be null";
+  if (output_file_.empty()) { 
+    GTEST_LOG_(FATAL) << "XML output file may not be null"; 
   }
 }
 
 // Called after the unit test ends.
 void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                   int /*iteration*/) {
-  FILE* xmlout = OpenFileForWriting(output_file_);
+  FILE* xmlout = OpenFileForWriting(output_file_); 
   std::stringstream stream;
   PrintXmlUnitTest(&stream, unit_test);
   fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
   fclose(xmlout);
 }
 
-void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
-    const std::vector<TestSuite*>& test_suites) {
-  FILE* xmlout = OpenFileForWriting(output_file_);
-  std::stringstream stream;
-  PrintXmlTestsList(&stream, test_suites);
-  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
-  fclose(xmlout);
-}
-
+void XmlUnitTestResultPrinter::ListTestsMatchingFilter( 
+    const std::vector<TestSuite*>& test_suites) { 
+  FILE* xmlout = OpenFileForWriting(output_file_); 
+  std::stringstream stream; 
+  PrintXmlTestsList(&stream, test_suites); 
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); 
+  fclose(xmlout); 
+} 
+ 
 // Returns an XML-escaped copy of the input string str.  If is_attribute
 // is true, the text is meant to appear as an attribute value, and
 // normalizable whitespace is preserved by replacing it with character
@@ -4064,12 +4064,12 @@ std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
 
 // The following routines generate an XML representation of a UnitTest
 // object.
-// GOOGLETEST_CM0009 DO NOT DELETE
+// GOOGLETEST_CM0009 DO NOT DELETE 
 //
 // This is how Google Test concepts map to the DTD:
 //
 // <testsuites name="AllTests">        <-- corresponds to a UnitTest object
-//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object
+//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object 
 //     <testcase name="test-name">     <-- corresponds to a TestInfo object
 //       <failure message="...">...</failure>
 //       <failure message="...">...</failure>
@@ -4093,15 +4093,15 @@ static bool PortableLocaltime(time_t seconds, struct tm* out) {
   // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
   // Windows' localtime(), which has a thread-local tm buffer.
   struct tm* tm_ptr = localtime(&seconds);  // NOLINT
-  if (tm_ptr == nullptr) return false;
+  if (tm_ptr == nullptr) return false; 
   *out = *tm_ptr;
   return true;
-#elif defined(__STDC_LIB_EXT1__)
-  // Uses localtime_s when available as localtime_r is only available from
-  // C23 standard.
-  return localtime_s(&seconds, out) != nullptr;
+#elif defined(__STDC_LIB_EXT1__) 
+  // Uses localtime_s when available as localtime_r is only available from 
+  // C23 standard. 
+  return localtime_s(&seconds, out) != nullptr; 
 #else
-  return localtime_r(&seconds, out) != nullptr;
+  return localtime_r(&seconds, out) != nullptr; 
 #endif
 }
 
@@ -4111,14 +4111,14 @@ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
   struct tm time_struct;
   if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
     return "";
-  // YYYY-MM-DDThh:mm:ss.sss
+  // YYYY-MM-DDThh:mm:ss.sss 
   return StreamableToString(time_struct.tm_year + 1900) + "-" +
       String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
       String::FormatIntWidth2(time_struct.tm_mday) + "T" +
       String::FormatIntWidth2(time_struct.tm_hour) + ":" +
       String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec) + "." +
-      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
+      String::FormatIntWidth2(time_struct.tm_sec) + "." + 
+      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3); 
 }
 
 // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
@@ -4128,7 +4128,7 @@ void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
   *stream << "<![CDATA[";
   for (;;) {
     const char* const next_segment = strstr(segment, "]]>");
-    if (next_segment != nullptr) {
+    if (next_segment != nullptr) { 
       stream->write(
           segment, static_cast<std::streamsize>(next_segment - segment));
       *stream << "]]>]]&gt;<![CDATA[";
@@ -4147,7 +4147,7 @@ void XmlUnitTestResultPrinter::OutputXmlAttribute(
     const std::string& name,
     const std::string& value) {
   const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
+      GetReservedOutputAttributesForElement(element_name); 
 
   GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
                    allowed_names.end())
@@ -4157,167 +4157,167 @@ void XmlUnitTestResultPrinter::OutputXmlAttribute(
   *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
 }
 
-// Streams a test suite XML stanza containing the given test result.
-void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
-    ::std::ostream* stream, const TestResult& result) {
-  // Output the boilerplate for a minimal test suite with one test.
-  *stream << "  <testsuite";
-  OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
-  OutputXmlAttribute(stream, "testsuite", "tests", "1");
-  OutputXmlAttribute(stream, "testsuite", "failures", "1");
-  OutputXmlAttribute(stream, "testsuite", "disabled", "0");
-  OutputXmlAttribute(stream, "testsuite", "skipped", "0");
-  OutputXmlAttribute(stream, "testsuite", "errors", "0");
-  OutputXmlAttribute(stream, "testsuite", "time",
-                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(
-      stream, "testsuite", "timestamp",
-      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
-  *stream << ">";
-
-  // Output the boilerplate for a minimal test case with a single test.
-  *stream << "    <testcase";
-  OutputXmlAttribute(stream, "testcase", "name", "");
-  OutputXmlAttribute(stream, "testcase", "status", "run");
-  OutputXmlAttribute(stream, "testcase", "result", "completed");
-  OutputXmlAttribute(stream, "testcase", "classname", "");
-  OutputXmlAttribute(stream, "testcase", "time",
-                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(
-      stream, "testcase", "timestamp",
-      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
-
-  // Output the actual test result.
-  OutputXmlTestResult(stream, result);
-
-  // Complete the test suite.
-  *stream << "  </testsuite>\n";
-}
-
+// Streams a test suite XML stanza containing the given test result. 
+void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult( 
+    ::std::ostream* stream, const TestResult& result) { 
+  // Output the boilerplate for a minimal test suite with one test. 
+  *stream << "  <testsuite"; 
+  OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure"); 
+  OutputXmlAttribute(stream, "testsuite", "tests", "1"); 
+  OutputXmlAttribute(stream, "testsuite", "failures", "1"); 
+  OutputXmlAttribute(stream, "testsuite", "disabled", "0"); 
+  OutputXmlAttribute(stream, "testsuite", "skipped", "0"); 
+  OutputXmlAttribute(stream, "testsuite", "errors", "0"); 
+  OutputXmlAttribute(stream, "testsuite", "time", 
+                     FormatTimeInMillisAsSeconds(result.elapsed_time())); 
+  OutputXmlAttribute( 
+      stream, "testsuite", "timestamp", 
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); 
+  *stream << ">"; 
+ 
+  // Output the boilerplate for a minimal test case with a single test. 
+  *stream << "    <testcase"; 
+  OutputXmlAttribute(stream, "testcase", "name", ""); 
+  OutputXmlAttribute(stream, "testcase", "status", "run"); 
+  OutputXmlAttribute(stream, "testcase", "result", "completed"); 
+  OutputXmlAttribute(stream, "testcase", "classname", ""); 
+  OutputXmlAttribute(stream, "testcase", "time", 
+                     FormatTimeInMillisAsSeconds(result.elapsed_time())); 
+  OutputXmlAttribute( 
+      stream, "testcase", "timestamp", 
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); 
+ 
+  // Output the actual test result. 
+  OutputXmlTestResult(stream, result); 
+ 
+  // Complete the test suite. 
+  *stream << "  </testsuite>\n"; 
+} 
+ 
 // Prints an XML representation of a TestInfo object.
 void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
-                                                 const char* test_suite_name,
+                                                 const char* test_suite_name, 
                                                  const TestInfo& test_info) {
   const TestResult& result = *test_info.result();
-  const std::string kTestsuite = "testcase";
-
-  if (test_info.is_in_another_shard()) {
-    return;
-  }
+  const std::string kTestsuite = "testcase"; 
 
+  if (test_info.is_in_another_shard()) { 
+    return; 
+  } 
+ 
   *stream << "    <testcase";
-  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
+  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name()); 
 
-  if (test_info.value_param() != nullptr) {
-    OutputXmlAttribute(stream, kTestsuite, "value_param",
+  if (test_info.value_param() != nullptr) { 
+    OutputXmlAttribute(stream, kTestsuite, "value_param", 
                        test_info.value_param());
   }
-  if (test_info.type_param() != nullptr) {
-    OutputXmlAttribute(stream, kTestsuite, "type_param",
-                       test_info.type_param());
-  }
-  if (GTEST_FLAG(list_tests)) {
-    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
-    OutputXmlAttribute(stream, kTestsuite, "line",
-                       StreamableToString(test_info.line()));
-    *stream << " />\n";
-    return;
+  if (test_info.type_param() != nullptr) { 
+    OutputXmlAttribute(stream, kTestsuite, "type_param", 
+                       test_info.type_param()); 
   }
+  if (GTEST_FLAG(list_tests)) { 
+    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file()); 
+    OutputXmlAttribute(stream, kTestsuite, "line", 
+                       StreamableToString(test_info.line())); 
+    *stream << " />\n"; 
+    return; 
+  } 
 
-  OutputXmlAttribute(stream, kTestsuite, "status",
+  OutputXmlAttribute(stream, kTestsuite, "status", 
                      test_info.should_run() ? "run" : "notrun");
-  OutputXmlAttribute(stream, kTestsuite, "result",
-                     test_info.should_run()
-                         ? (result.Skipped() ? "skipped" : "completed")
-                         : "suppressed");
-  OutputXmlAttribute(stream, kTestsuite, "time",
+  OutputXmlAttribute(stream, kTestsuite, "result", 
+                     test_info.should_run() 
+                         ? (result.Skipped() ? "skipped" : "completed") 
+                         : "suppressed"); 
+  OutputXmlAttribute(stream, kTestsuite, "time", 
                      FormatTimeInMillisAsSeconds(result.elapsed_time()));
-  OutputXmlAttribute(
-      stream, kTestsuite, "timestamp",
-      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
-  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
-
-  OutputXmlTestResult(stream, result);
-}
-
-void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
-                                                   const TestResult& result) {
+  OutputXmlAttribute( 
+      stream, kTestsuite, "timestamp", 
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp())); 
+  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name); 
+
+  OutputXmlTestResult(stream, result); 
+} 
+ 
+void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream, 
+                                                   const TestResult& result) { 
   int failures = 0;
-  int skips = 0;
+  int skips = 0; 
   for (int i = 0; i < result.total_part_count(); ++i) {
     const TestPartResult& part = result.GetTestPartResult(i);
     if (part.failed()) {
-      if (++failures == 1 && skips == 0) {
+      if (++failures == 1 && skips == 0) { 
         *stream << ">\n";
       }
-      const std::string location =
-          internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                          part.line_number());
-      const std::string summary = location + "\n" + part.summary();
+      const std::string location = 
+          internal::FormatCompilerIndependentFileLocation(part.file_name(), 
+                                                          part.line_number()); 
+      const std::string summary = location + "\n" + part.summary(); 
       *stream << "      <failure message=\""
-              << EscapeXmlAttribute(summary)
+              << EscapeXmlAttribute(summary) 
               << "\" type=\"\">";
-      const std::string detail = location + "\n" + part.message();
+      const std::string detail = location + "\n" + part.message(); 
       OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
       *stream << "</failure>\n";
-    } else if (part.skipped()) {
-      if (++skips == 1 && failures == 0) {
-        *stream << ">\n";
-      }
-      const std::string location =
-          internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                          part.line_number());
-      const std::string summary = location + "\n" + part.summary();
-      *stream << "      <skipped message=\""
-              << EscapeXmlAttribute(summary.c_str()) << "\">";
-      const std::string detail = location + "\n" + part.message();
-      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
-      *stream << "</skipped>\n";
+    } else if (part.skipped()) { 
+      if (++skips == 1 && failures == 0) { 
+        *stream << ">\n"; 
+      } 
+      const std::string location = 
+          internal::FormatCompilerIndependentFileLocation(part.file_name(), 
+                                                          part.line_number()); 
+      const std::string summary = location + "\n" + part.summary(); 
+      *stream << "      <skipped message=\"" 
+              << EscapeXmlAttribute(summary.c_str()) << "\">"; 
+      const std::string detail = location + "\n" + part.message(); 
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); 
+      *stream << "</skipped>\n"; 
     }
   }
 
-  if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
+  if (failures == 0 && skips == 0 && result.test_property_count() == 0) { 
     *stream << " />\n";
-  } else {
-    if (failures == 0 && skips == 0) {
-      *stream << ">\n";
-    }
-    OutputXmlTestProperties(stream, result);
+  } else { 
+    if (failures == 0 && skips == 0) { 
+      *stream << ">\n"; 
+    } 
+    OutputXmlTestProperties(stream, result); 
     *stream << "    </testcase>\n";
-  }
+  } 
 }
 
-// Prints an XML representation of a TestSuite object
-void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
-                                                 const TestSuite& test_suite) {
+// Prints an XML representation of a TestSuite object 
+void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream, 
+                                                 const TestSuite& test_suite) { 
   const std::string kTestsuite = "testsuite";
   *stream << "  <" << kTestsuite;
-  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
+  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name()); 
   OutputXmlAttribute(stream, kTestsuite, "tests",
-                     StreamableToString(test_suite.reportable_test_count()));
-  if (!GTEST_FLAG(list_tests)) {
-    OutputXmlAttribute(stream, kTestsuite, "failures",
-                       StreamableToString(test_suite.failed_test_count()));
-    OutputXmlAttribute(
-        stream, kTestsuite, "disabled",
-        StreamableToString(test_suite.reportable_disabled_test_count()));
-    OutputXmlAttribute(stream, kTestsuite, "skipped",
-                       StreamableToString(test_suite.skipped_test_count()));
-
-    OutputXmlAttribute(stream, kTestsuite, "errors", "0");
-
-    OutputXmlAttribute(stream, kTestsuite, "time",
-                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
-    OutputXmlAttribute(
-        stream, kTestsuite, "timestamp",
-        FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
-    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
-  }
-  *stream << ">\n";
-  for (int i = 0; i < test_suite.total_test_count(); ++i) {
-    if (test_suite.GetTestInfo(i)->is_reportable())
-      OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
-  }
+                     StreamableToString(test_suite.reportable_test_count())); 
+  if (!GTEST_FLAG(list_tests)) { 
+    OutputXmlAttribute(stream, kTestsuite, "failures", 
+                       StreamableToString(test_suite.failed_test_count())); 
+    OutputXmlAttribute( 
+        stream, kTestsuite, "disabled", 
+        StreamableToString(test_suite.reportable_disabled_test_count())); 
+    OutputXmlAttribute(stream, kTestsuite, "skipped", 
+                       StreamableToString(test_suite.skipped_test_count())); 
+ 
+    OutputXmlAttribute(stream, kTestsuite, "errors", "0"); 
+ 
+    OutputXmlAttribute(stream, kTestsuite, "time", 
+                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time())); 
+    OutputXmlAttribute( 
+        stream, kTestsuite, "timestamp", 
+        FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp())); 
+    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result()); 
+  }
+  *stream << ">\n"; 
+  for (int i = 0; i < test_suite.total_test_count(); ++i) { 
+    if (test_suite.GetTestInfo(i)->is_reportable()) 
+      OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i)); 
+  } 
   *stream << "  </" << kTestsuite << ">\n";
 }
 
@@ -4337,8 +4337,8 @@ void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
       stream, kTestsuites, "disabled",
       StreamableToString(unit_test.reportable_disabled_test_count()));
   OutputXmlAttribute(stream, kTestsuites, "errors", "0");
-  OutputXmlAttribute(stream, kTestsuites, "time",
-                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+  OutputXmlAttribute(stream, kTestsuites, "time", 
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); 
   OutputXmlAttribute(
       stream, kTestsuites, "timestamp",
       FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
@@ -4352,42 +4352,42 @@ void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
   OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
   *stream << ">\n";
 
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
-      PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
-  }
-
-  // If there was a test failure outside of one of the test suites (like in a
-  // test environment) include that in the output.
-  if (unit_test.ad_hoc_test_result().Failed()) {
-    OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
-  }
-
-  *stream << "</" << kTestsuites << ">\n";
-}
-
-void XmlUnitTestResultPrinter::PrintXmlTestsList(
-    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
-  const std::string kTestsuites = "testsuites";
-
-  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-  *stream << "<" << kTestsuites;
-
-  int total_tests = 0;
-  for (auto test_suite : test_suites) {
-    total_tests += test_suite->total_test_count();
-  }
-  OutputXmlAttribute(stream, kTestsuites, "tests",
-                     StreamableToString(total_tests));
-  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
-  *stream << ">\n";
-
-  for (auto test_suite : test_suites) {
-    PrintXmlTestSuite(stream, *test_suite);
-  }
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { 
+    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) 
+      PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i)); 
+  }
+ 
+  // If there was a test failure outside of one of the test suites (like in a 
+  // test environment) include that in the output. 
+  if (unit_test.ad_hoc_test_result().Failed()) { 
+    OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result()); 
+  } 
+ 
   *stream << "</" << kTestsuites << ">\n";
 }
 
+void XmlUnitTestResultPrinter::PrintXmlTestsList( 
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) { 
+  const std::string kTestsuites = "testsuites"; 
+ 
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; 
+  *stream << "<" << kTestsuites; 
+ 
+  int total_tests = 0; 
+  for (auto test_suite : test_suites) { 
+    total_tests += test_suite->total_test_count(); 
+  } 
+  OutputXmlAttribute(stream, kTestsuites, "tests", 
+                     StreamableToString(total_tests)); 
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); 
+  *stream << ">\n"; 
+ 
+  for (auto test_suite : test_suites) { 
+    PrintXmlTestSuite(stream, *test_suite); 
+  } 
+  *stream << "</" << kTestsuites << ">\n"; 
+} 
+ 
 // Produces a string representing the test properties in a result as space
 // delimited XML attributes based on the property key="value" pairs.
 std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
@@ -4401,468 +4401,468 @@ std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
   return attributes.GetString();
 }
 
-void XmlUnitTestResultPrinter::OutputXmlTestProperties(
-    std::ostream* stream, const TestResult& result) {
-  const std::string kProperties = "properties";
-  const std::string kProperty = "property";
-
-  if (result.test_property_count() <= 0) {
-    return;
-  }
-
-  *stream << "<" << kProperties << ">\n";
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    *stream << "<" << kProperty;
-    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
-    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
-    *stream << "/>\n";
-  }
-  *stream << "</" << kProperties << ">\n";
-}
-
+void XmlUnitTestResultPrinter::OutputXmlTestProperties( 
+    std::ostream* stream, const TestResult& result) { 
+  const std::string kProperties = "properties"; 
+  const std::string kProperty = "property"; 
+ 
+  if (result.test_property_count() <= 0) { 
+    return; 
+  } 
+ 
+  *stream << "<" << kProperties << ">\n"; 
+  for (int i = 0; i < result.test_property_count(); ++i) { 
+    const TestProperty& property = result.GetTestProperty(i); 
+    *stream << "<" << kProperty; 
+    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\""; 
+    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\""; 
+    *stream << "/>\n"; 
+  } 
+  *stream << "</" << kProperties << ">\n"; 
+} 
+ 
 // End XmlUnitTestResultPrinter
 
-// This class generates an JSON output file.
-class JsonUnitTestResultPrinter : public EmptyTestEventListener {
- public:
-  explicit JsonUnitTestResultPrinter(const char* output_file);
-
-  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
-
-  // Prints an JSON summary of all unit tests.
-  static void PrintJsonTestList(::std::ostream* stream,
-                                const std::vector<TestSuite*>& test_suites);
-
- private:
-  // Returns an JSON-escaped copy of the input string str.
-  static std::string EscapeJson(const std::string& str);
-
-  //// Verifies that the given attribute belongs to the given element and
-  //// streams the attribute as JSON.
-  static void OutputJsonKey(std::ostream* stream,
-                            const std::string& element_name,
-                            const std::string& name,
-                            const std::string& value,
-                            const std::string& indent,
-                            bool comma = true);
-  static void OutputJsonKey(std::ostream* stream,
-                            const std::string& element_name,
-                            const std::string& name,
-                            int value,
-                            const std::string& indent,
-                            bool comma = true);
-
-  // Streams a test suite JSON stanza containing the given test result.
-  //
-  // Requires: result.Failed()
-  static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
-                                               const TestResult& result);
-
-  // Streams a JSON representation of a TestResult object.
-  static void OutputJsonTestResult(::std::ostream* stream,
-                                   const TestResult& result);
-
-  // Streams a JSON representation of a TestInfo object.
-  static void OutputJsonTestInfo(::std::ostream* stream,
-                                 const char* test_suite_name,
-                                 const TestInfo& test_info);
-
-  // Prints a JSON representation of a TestSuite object
-  static void PrintJsonTestSuite(::std::ostream* stream,
-                                 const TestSuite& test_suite);
-
-  // Prints a JSON summary of unit_test to output stream out.
-  static void PrintJsonUnitTest(::std::ostream* stream,
-                                const UnitTest& unit_test);
-
-  // Produces a string representing the test properties in a result as
-  // a JSON dictionary.
-  static std::string TestPropertiesAsJson(const TestResult& result,
-                                          const std::string& indent);
-
-  // The output file.
-  const std::string output_file_;
-
-  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
-};
-
-// Creates a new JsonUnitTestResultPrinter.
-JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
-    : output_file_(output_file) {
-  if (output_file_.empty()) {
-    GTEST_LOG_(FATAL) << "JSON output file may not be null";
-  }
-}
-
-void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
-                                                  int /*iteration*/) {
-  FILE* jsonout = OpenFileForWriting(output_file_);
-  std::stringstream stream;
-  PrintJsonUnitTest(&stream, unit_test);
-  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
-  fclose(jsonout);
-}
-
-// Returns an JSON-escaped copy of the input string str.
-std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
-  Message m;
-
-  for (size_t i = 0; i < str.size(); ++i) {
-    const char ch = str[i];
-    switch (ch) {
-      case '\\':
-      case '"':
-      case '/':
-        m << '\\' << ch;
-        break;
-      case '\b':
-        m << "\\b";
-        break;
-      case '\t':
-        m << "\\t";
-        break;
-      case '\n':
-        m << "\\n";
-        break;
-      case '\f':
-        m << "\\f";
-        break;
-      case '\r':
-        m << "\\r";
-        break;
-      default:
-        if (ch < ' ') {
-          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
-        } else {
-          m << ch;
-        }
-        break;
-    }
-  }
-
-  return m.GetString();
-}
-
-// The following routines generate an JSON representation of a UnitTest
-// object.
-
-// Formats the given time in milliseconds as seconds.
-static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
-  ::std::stringstream ss;
-  ss << (static_cast<double>(ms) * 1e-3) << "s";
-  return ss.str();
-}
-
-// Converts the given epoch time in milliseconds to a date string in the
-// RFC3339 format, without the timezone information.
-static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
-  struct tm time_struct;
-  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
-    return "";
-  // YYYY-MM-DDThh:mm:ss
-  return StreamableToString(time_struct.tm_year + 1900) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
-      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
-      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
-      String::FormatIntWidth2(time_struct.tm_min) + ":" +
-      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
-}
-
-static inline std::string Indent(size_t width) {
-  return std::string(width, ' ');
-}
-
-void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    const std::string& value,
-    const std::string& indent,
-    bool comma) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Key \"" << name << "\" is not allowed for value \"" << element_name
-      << "\".";
-
-  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
-  if (comma)
-    *stream << ",\n";
-}
-
-void JsonUnitTestResultPrinter::OutputJsonKey(
-    std::ostream* stream,
-    const std::string& element_name,
-    const std::string& name,
-    int value,
-    const std::string& indent,
-    bool comma) {
-  const std::vector<std::string>& allowed_names =
-      GetReservedOutputAttributesForElement(element_name);
-
-  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
-                   allowed_names.end())
-      << "Key \"" << name << "\" is not allowed for value \"" << element_name
-      << "\".";
-
-  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
-  if (comma)
-    *stream << ",\n";
-}
-
-// Streams a test suite JSON stanza containing the given test result.
-void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
-    ::std::ostream* stream, const TestResult& result) {
-  // Output the boilerplate for a new test suite.
-  *stream << Indent(4) << "{\n";
-  OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
-  OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
-  if (!GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
-    OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
-    OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
-    OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
-    OutputJsonKey(stream, "testsuite", "time",
-                  FormatTimeInMillisAsDuration(result.elapsed_time()),
-                  Indent(6));
-    OutputJsonKey(stream, "testsuite", "timestamp",
-                  FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
-                  Indent(6));
-  }
-  *stream << Indent(6) << "\"testsuite\": [\n";
-
-  // Output the boilerplate for a new test case.
-  *stream << Indent(8) << "{\n";
-  OutputJsonKey(stream, "testcase", "name", "", Indent(10));
-  OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
-  OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
-  OutputJsonKey(stream, "testcase", "timestamp",
-                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
-                Indent(10));
-  OutputJsonKey(stream, "testcase", "time",
-                FormatTimeInMillisAsDuration(result.elapsed_time()),
-                Indent(10));
-  OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
-  *stream << TestPropertiesAsJson(result, Indent(10));
-
-  // Output the actual test result.
-  OutputJsonTestResult(stream, result);
-
-  // Finish the test suite.
-  *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
-}
-
-// Prints a JSON representation of a TestInfo object.
-void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
-                                                   const char* test_suite_name,
-                                                   const TestInfo& test_info) {
-  const TestResult& result = *test_info.result();
-  const std::string kTestsuite = "testcase";
-  const std::string kIndent = Indent(10);
-
-  *stream << Indent(8) << "{\n";
-  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
-
-  if (test_info.value_param() != nullptr) {
-    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
-                  kIndent);
-  }
-  if (test_info.type_param() != nullptr) {
-    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
-                  kIndent);
-  }
-  if (GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
-    *stream << "\n" << Indent(8) << "}";
-    return;
-  }
-
-  OutputJsonKey(stream, kTestsuite, "status",
-                test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
-  OutputJsonKey(stream, kTestsuite, "result",
-                test_info.should_run()
-                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
-                    : "SUPPRESSED",
-                kIndent);
-  OutputJsonKey(stream, kTestsuite, "timestamp",
-                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
-                kIndent);
-  OutputJsonKey(stream, kTestsuite, "time",
-                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
-  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
-                false);
-  *stream << TestPropertiesAsJson(result, kIndent);
-
-  OutputJsonTestResult(stream, result);
-}
-
-void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
-                                                     const TestResult& result) {
-  const std::string kIndent = Indent(10);
-
-  int failures = 0;
-  for (int i = 0; i < result.total_part_count(); ++i) {
-    const TestPartResult& part = result.GetTestPartResult(i);
-    if (part.failed()) {
-      *stream << ",\n";
-      if (++failures == 1) {
-        *stream << kIndent << "\"" << "failures" << "\": [\n";
-      }
-      const std::string location =
-          internal::FormatCompilerIndependentFileLocation(part.file_name(),
-                                                          part.line_number());
-      const std::string message = EscapeJson(location + "\n" + part.message());
-      *stream << kIndent << "  {\n"
-              << kIndent << "    \"failure\": \"" << message << "\",\n"
-              << kIndent << "    \"type\": \"\"\n"
-              << kIndent << "  }";
-    }
-  }
-
-  if (failures > 0)
-    *stream << "\n" << kIndent << "]";
-  *stream << "\n" << Indent(8) << "}";
-}
-
-// Prints an JSON representation of a TestSuite object
-void JsonUnitTestResultPrinter::PrintJsonTestSuite(
-    std::ostream* stream, const TestSuite& test_suite) {
-  const std::string kTestsuite = "testsuite";
-  const std::string kIndent = Indent(6);
-
-  *stream << Indent(4) << "{\n";
-  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
-  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
-                kIndent);
-  if (!GTEST_FLAG(list_tests)) {
-    OutputJsonKey(stream, kTestsuite, "failures",
-                  test_suite.failed_test_count(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "disabled",
-                  test_suite.reportable_disabled_test_count(), kIndent);
-    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
-    OutputJsonKey(
-        stream, kTestsuite, "timestamp",
-        FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
-        kIndent);
-    OutputJsonKey(stream, kTestsuite, "time",
-                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
-                  kIndent, false);
-    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
-            << ",\n";
-  }
-
-  *stream << kIndent << "\"" << kTestsuite << "\": [\n";
-
-  bool comma = false;
-  for (int i = 0; i < test_suite.total_test_count(); ++i) {
-    if (test_suite.GetTestInfo(i)->is_reportable()) {
-      if (comma) {
-        *stream << ",\n";
-      } else {
-        comma = true;
-      }
-      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
-    }
-  }
-  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
-}
-
-// Prints a JSON summary of unit_test to output stream out.
-void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
-                                                  const UnitTest& unit_test) {
-  const std::string kTestsuites = "testsuites";
-  const std::string kIndent = Indent(2);
-  *stream << "{\n";
-
-  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "disabled",
-                unit_test.reportable_disabled_test_count(), kIndent);
-  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
-  if (GTEST_FLAG(shuffle)) {
-    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
-                  kIndent);
-  }
-  OutputJsonKey(stream, kTestsuites, "timestamp",
-                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
-                kIndent);
-  OutputJsonKey(stream, kTestsuites, "time",
-                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
-                false);
-
-  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
-          << ",\n";
-
-  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
-  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
-
-  bool comma = false;
-  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
-    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
-      if (comma) {
-        *stream << ",\n";
-      } else {
-        comma = true;
-      }
-      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
-    }
-  }
-
-  // If there was a test failure outside of one of the test suites (like in a
-  // test environment) include that in the output.
-  if (unit_test.ad_hoc_test_result().Failed()) {
-    OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
-  }
-
-  *stream << "\n" << kIndent << "]\n" << "}\n";
-}
-
-void JsonUnitTestResultPrinter::PrintJsonTestList(
-    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
-  const std::string kTestsuites = "testsuites";
-  const std::string kIndent = Indent(2);
-  *stream << "{\n";
-  int total_tests = 0;
-  for (auto test_suite : test_suites) {
-    total_tests += test_suite->total_test_count();
-  }
-  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
-
-  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
-  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
-
-  for (size_t i = 0; i < test_suites.size(); ++i) {
-    if (i != 0) {
-      *stream << ",\n";
-    }
-    PrintJsonTestSuite(stream, *test_suites[i]);
-  }
-
-  *stream << "\n"
-          << kIndent << "]\n"
-          << "}\n";
-}
-// Produces a string representing the test properties in a result as
-// a JSON dictionary.
-std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
-    const TestResult& result, const std::string& indent) {
-  Message attributes;
-  for (int i = 0; i < result.test_property_count(); ++i) {
-    const TestProperty& property = result.GetTestProperty(i);
-    attributes << ",\n" << indent << "\"" << property.key() << "\": "
-               << "\"" << EscapeJson(property.value()) << "\"";
-  }
-  return attributes.GetString();
-}
-
-// End JsonUnitTestResultPrinter
-
+// This class generates an JSON output file. 
+class JsonUnitTestResultPrinter : public EmptyTestEventListener { 
+ public: 
+  explicit JsonUnitTestResultPrinter(const char* output_file); 
+ 
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; 
+ 
+  // Prints an JSON summary of all unit tests. 
+  static void PrintJsonTestList(::std::ostream* stream, 
+                                const std::vector<TestSuite*>& test_suites); 
+ 
+ private: 
+  // Returns an JSON-escaped copy of the input string str. 
+  static std::string EscapeJson(const std::string& str); 
+ 
+  //// Verifies that the given attribute belongs to the given element and 
+  //// streams the attribute as JSON. 
+  static void OutputJsonKey(std::ostream* stream, 
+                            const std::string& element_name, 
+                            const std::string& name, 
+                            const std::string& value, 
+                            const std::string& indent, 
+                            bool comma = true); 
+  static void OutputJsonKey(std::ostream* stream, 
+                            const std::string& element_name, 
+                            const std::string& name, 
+                            int value, 
+                            const std::string& indent, 
+                            bool comma = true); 
+ 
+  // Streams a test suite JSON stanza containing the given test result. 
+  // 
+  // Requires: result.Failed() 
+  static void OutputJsonTestSuiteForTestResult(::std::ostream* stream, 
+                                               const TestResult& result); 
+ 
+  // Streams a JSON representation of a TestResult object. 
+  static void OutputJsonTestResult(::std::ostream* stream, 
+                                   const TestResult& result); 
+ 
+  // Streams a JSON representation of a TestInfo object. 
+  static void OutputJsonTestInfo(::std::ostream* stream, 
+                                 const char* test_suite_name, 
+                                 const TestInfo& test_info); 
+ 
+  // Prints a JSON representation of a TestSuite object 
+  static void PrintJsonTestSuite(::std::ostream* stream, 
+                                 const TestSuite& test_suite); 
+ 
+  // Prints a JSON summary of unit_test to output stream out. 
+  static void PrintJsonUnitTest(::std::ostream* stream, 
+                                const UnitTest& unit_test); 
+ 
+  // Produces a string representing the test properties in a result as 
+  // a JSON dictionary. 
+  static std::string TestPropertiesAsJson(const TestResult& result, 
+                                          const std::string& indent); 
+ 
+  // The output file. 
+  const std::string output_file_; 
+ 
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter); 
+}; 
+ 
+// Creates a new JsonUnitTestResultPrinter. 
+JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file) 
+    : output_file_(output_file) { 
+  if (output_file_.empty()) { 
+    GTEST_LOG_(FATAL) << "JSON output file may not be null"; 
+  } 
+} 
+ 
+void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, 
+                                                  int /*iteration*/) { 
+  FILE* jsonout = OpenFileForWriting(output_file_); 
+  std::stringstream stream; 
+  PrintJsonUnitTest(&stream, unit_test); 
+  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str()); 
+  fclose(jsonout); 
+} 
+ 
+// Returns an JSON-escaped copy of the input string str. 
+std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) { 
+  Message m; 
+ 
+  for (size_t i = 0; i < str.size(); ++i) { 
+    const char ch = str[i]; 
+    switch (ch) { 
+      case '\\': 
+      case '"': 
+      case '/': 
+        m << '\\' << ch; 
+        break; 
+      case '\b': 
+        m << "\\b"; 
+        break; 
+      case '\t': 
+        m << "\\t"; 
+        break; 
+      case '\n': 
+        m << "\\n"; 
+        break; 
+      case '\f': 
+        m << "\\f"; 
+        break; 
+      case '\r': 
+        m << "\\r"; 
+        break; 
+      default: 
+        if (ch < ' ') { 
+          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch)); 
+        } else { 
+          m << ch; 
+        } 
+        break; 
+    } 
+  } 
+ 
+  return m.GetString(); 
+} 
+ 
+// The following routines generate an JSON representation of a UnitTest 
+// object. 
+ 
+// Formats the given time in milliseconds as seconds. 
+static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) { 
+  ::std::stringstream ss; 
+  ss << (static_cast<double>(ms) * 1e-3) << "s"; 
+  return ss.str(); 
+} 
+ 
+// Converts the given epoch time in milliseconds to a date string in the 
+// RFC3339 format, without the timezone information. 
+static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) { 
+  struct tm time_struct; 
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct)) 
+    return ""; 
+  // YYYY-MM-DDThh:mm:ss 
+  return StreamableToString(time_struct.tm_year + 1900) + "-" + 
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" + 
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" + 
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" + 
+      String::FormatIntWidth2(time_struct.tm_min) + ":" + 
+      String::FormatIntWidth2(time_struct.tm_sec) + "Z"; 
+} 
+ 
+static inline std::string Indent(size_t width) { 
+  return std::string(width, ' '); 
+} 
+ 
+void JsonUnitTestResultPrinter::OutputJsonKey( 
+    std::ostream* stream, 
+    const std::string& element_name, 
+    const std::string& name, 
+    const std::string& value, 
+    const std::string& indent, 
+    bool comma) { 
+  const std::vector<std::string>& allowed_names = 
+      GetReservedOutputAttributesForElement(element_name); 
+ 
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != 
+                   allowed_names.end()) 
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name 
+      << "\"."; 
+ 
+  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\""; 
+  if (comma) 
+    *stream << ",\n"; 
+} 
+ 
+void JsonUnitTestResultPrinter::OutputJsonKey( 
+    std::ostream* stream, 
+    const std::string& element_name, 
+    const std::string& name, 
+    int value, 
+    const std::string& indent, 
+    bool comma) { 
+  const std::vector<std::string>& allowed_names = 
+      GetReservedOutputAttributesForElement(element_name); 
+ 
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != 
+                   allowed_names.end()) 
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name 
+      << "\"."; 
+ 
+  *stream << indent << "\"" << name << "\": " << StreamableToString(value); 
+  if (comma) 
+    *stream << ",\n"; 
+} 
+ 
+// Streams a test suite JSON stanza containing the given test result. 
+void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult( 
+    ::std::ostream* stream, const TestResult& result) { 
+  // Output the boilerplate for a new test suite. 
+  *stream << Indent(4) << "{\n"; 
+  OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6)); 
+  OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6)); 
+  if (!GTEST_FLAG(list_tests)) { 
+    OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6)); 
+    OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6)); 
+    OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6)); 
+    OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6)); 
+    OutputJsonKey(stream, "testsuite", "time", 
+                  FormatTimeInMillisAsDuration(result.elapsed_time()), 
+                  Indent(6)); 
+    OutputJsonKey(stream, "testsuite", "timestamp", 
+                  FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), 
+                  Indent(6)); 
+  } 
+  *stream << Indent(6) << "\"testsuite\": [\n"; 
+ 
+  // Output the boilerplate for a new test case. 
+  *stream << Indent(8) << "{\n"; 
+  OutputJsonKey(stream, "testcase", "name", "", Indent(10)); 
+  OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10)); 
+  OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10)); 
+  OutputJsonKey(stream, "testcase", "timestamp", 
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), 
+                Indent(10)); 
+  OutputJsonKey(stream, "testcase", "time", 
+                FormatTimeInMillisAsDuration(result.elapsed_time()), 
+                Indent(10)); 
+  OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false); 
+  *stream << TestPropertiesAsJson(result, Indent(10)); 
+ 
+  // Output the actual test result. 
+  OutputJsonTestResult(stream, result); 
+ 
+  // Finish the test suite. 
+  *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}"; 
+} 
+ 
+// Prints a JSON representation of a TestInfo object. 
+void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream, 
+                                                   const char* test_suite_name, 
+                                                   const TestInfo& test_info) { 
+  const TestResult& result = *test_info.result(); 
+  const std::string kTestsuite = "testcase"; 
+  const std::string kIndent = Indent(10); 
+ 
+  *stream << Indent(8) << "{\n"; 
+  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent); 
+ 
+  if (test_info.value_param() != nullptr) { 
+    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(), 
+                  kIndent); 
+  } 
+  if (test_info.type_param() != nullptr) { 
+    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(), 
+                  kIndent); 
+  } 
+  if (GTEST_FLAG(list_tests)) { 
+    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent); 
+    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false); 
+    *stream << "\n" << Indent(8) << "}"; 
+    return; 
+  } 
+ 
+  OutputJsonKey(stream, kTestsuite, "status", 
+                test_info.should_run() ? "RUN" : "NOTRUN", kIndent); 
+  OutputJsonKey(stream, kTestsuite, "result", 
+                test_info.should_run() 
+                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED") 
+                    : "SUPPRESSED", 
+                kIndent); 
+  OutputJsonKey(stream, kTestsuite, "timestamp", 
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()), 
+                kIndent); 
+  OutputJsonKey(stream, kTestsuite, "time", 
+                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent); 
+  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent, 
+                false); 
+  *stream << TestPropertiesAsJson(result, kIndent); 
+ 
+  OutputJsonTestResult(stream, result); 
+} 
+ 
+void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream, 
+                                                     const TestResult& result) { 
+  const std::string kIndent = Indent(10); 
+ 
+  int failures = 0; 
+  for (int i = 0; i < result.total_part_count(); ++i) { 
+    const TestPartResult& part = result.GetTestPartResult(i); 
+    if (part.failed()) { 
+      *stream << ",\n"; 
+      if (++failures == 1) { 
+        *stream << kIndent << "\"" << "failures" << "\": [\n"; 
+      } 
+      const std::string location = 
+          internal::FormatCompilerIndependentFileLocation(part.file_name(), 
+                                                          part.line_number()); 
+      const std::string message = EscapeJson(location + "\n" + part.message()); 
+      *stream << kIndent << "  {\n" 
+              << kIndent << "    \"failure\": \"" << message << "\",\n" 
+              << kIndent << "    \"type\": \"\"\n" 
+              << kIndent << "  }"; 
+    } 
+  } 
+ 
+  if (failures > 0) 
+    *stream << "\n" << kIndent << "]"; 
+  *stream << "\n" << Indent(8) << "}"; 
+} 
+ 
+// Prints an JSON representation of a TestSuite object 
+void JsonUnitTestResultPrinter::PrintJsonTestSuite( 
+    std::ostream* stream, const TestSuite& test_suite) { 
+  const std::string kTestsuite = "testsuite"; 
+  const std::string kIndent = Indent(6); 
+ 
+  *stream << Indent(4) << "{\n"; 
+  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent); 
+  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(), 
+                kIndent); 
+  if (!GTEST_FLAG(list_tests)) { 
+    OutputJsonKey(stream, kTestsuite, "failures", 
+                  test_suite.failed_test_count(), kIndent); 
+    OutputJsonKey(stream, kTestsuite, "disabled", 
+                  test_suite.reportable_disabled_test_count(), kIndent); 
+    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent); 
+    OutputJsonKey( 
+        stream, kTestsuite, "timestamp", 
+        FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()), 
+        kIndent); 
+    OutputJsonKey(stream, kTestsuite, "time", 
+                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()), 
+                  kIndent, false); 
+    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent) 
+            << ",\n"; 
+  } 
+ 
+  *stream << kIndent << "\"" << kTestsuite << "\": [\n"; 
+ 
+  bool comma = false; 
+  for (int i = 0; i < test_suite.total_test_count(); ++i) { 
+    if (test_suite.GetTestInfo(i)->is_reportable()) { 
+      if (comma) { 
+        *stream << ",\n"; 
+      } else { 
+        comma = true; 
+      } 
+      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i)); 
+    } 
+  } 
+  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}"; 
+} 
+ 
+// Prints a JSON summary of unit_test to output stream out. 
+void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream, 
+                                                  const UnitTest& unit_test) { 
+  const std::string kTestsuites = "testsuites"; 
+  const std::string kIndent = Indent(2); 
+  *stream << "{\n"; 
+ 
+  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(), 
+                kIndent); 
+  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(), 
+                kIndent); 
+  OutputJsonKey(stream, kTestsuites, "disabled", 
+                unit_test.reportable_disabled_test_count(), kIndent); 
+  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent); 
+  if (GTEST_FLAG(shuffle)) { 
+    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(), 
+                  kIndent); 
+  } 
+  OutputJsonKey(stream, kTestsuites, "timestamp", 
+                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()), 
+                kIndent); 
+  OutputJsonKey(stream, kTestsuites, "time", 
+                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent, 
+                false); 
+ 
+  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent) 
+          << ",\n"; 
+ 
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent); 
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n"; 
+ 
+  bool comma = false; 
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { 
+    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) { 
+      if (comma) { 
+        *stream << ",\n"; 
+      } else { 
+        comma = true; 
+      } 
+      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i)); 
+    } 
+  } 
+ 
+  // If there was a test failure outside of one of the test suites (like in a 
+  // test environment) include that in the output. 
+  if (unit_test.ad_hoc_test_result().Failed()) { 
+    OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result()); 
+  } 
+ 
+  *stream << "\n" << kIndent << "]\n" << "}\n"; 
+} 
+ 
+void JsonUnitTestResultPrinter::PrintJsonTestList( 
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) { 
+  const std::string kTestsuites = "testsuites"; 
+  const std::string kIndent = Indent(2); 
+  *stream << "{\n"; 
+  int total_tests = 0; 
+  for (auto test_suite : test_suites) { 
+    total_tests += test_suite->total_test_count(); 
+  } 
+  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent); 
+ 
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent); 
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n"; 
+ 
+  for (size_t i = 0; i < test_suites.size(); ++i) { 
+    if (i != 0) { 
+      *stream << ",\n"; 
+    } 
+    PrintJsonTestSuite(stream, *test_suites[i]); 
+  } 
+ 
+  *stream << "\n" 
+          << kIndent << "]\n" 
+          << "}\n"; 
+} 
+// Produces a string representing the test properties in a result as 
+// a JSON dictionary. 
+std::string JsonUnitTestResultPrinter::TestPropertiesAsJson( 
+    const TestResult& result, const std::string& indent) { 
+  Message attributes; 
+  for (int i = 0; i < result.test_property_count(); ++i) { 
+    const TestProperty& property = result.GetTestProperty(i); 
+    attributes << ",\n" << indent << "\"" << property.key() << "\": " 
+               << "\"" << EscapeJson(property.value()) << "\""; 
+  } 
+  return attributes.GetString(); 
+} 
+ 
+// End JsonUnitTestResultPrinter 
+ 
 #if GTEST_CAN_STREAM_RESULTS_
 
 // Checks if str contains '=', '&', '%' or '\n' characters. If yes,
@@ -4870,8 +4870,8 @@ std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
 // example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
 // in both time and space -- important as the input str may contain an
 // arbitrarily long test failure message and stack trace.
-std::string StreamingListener::UrlEncode(const char* str) {
-  std::string result;
+std::string StreamingListener::UrlEncode(const char* str) { 
+  std::string result; 
   result.reserve(strlen(str) + 1);
   for (char ch = *str; ch != '\0'; ch = *++str) {
     switch (ch) {
@@ -4897,7 +4897,7 @@ void StreamingListener::SocketWriter::MakeConnection() {
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
   hints.ai_socktype = SOCK_STREAM;
-  addrinfo* servinfo = nullptr;
+  addrinfo* servinfo = nullptr; 
 
   // Use the getaddrinfo() to get a linked list of IP addresses for
   // the given host name.
@@ -4909,7 +4909,7 @@ void StreamingListener::SocketWriter::MakeConnection() {
   }
 
   // Loop through all the results and connect to the first we can.
-  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
+  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr; 
        cur_addr = cur_addr->ai_next) {
     sockfd_ = socket(
         cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
@@ -4933,82 +4933,82 @@ void StreamingListener::SocketWriter::MakeConnection() {
 // End of class Streaming Listener
 #endif  // GTEST_CAN_STREAM_RESULTS__
 
-// class OsStackTraceGetter
-
-const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
-    "... " GTEST_NAME_ " internal frames ...";
-
-std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-#if GTEST_HAS_ABSL
-  std::string result;
-
-  if (max_depth <= 0) {
-    return result;
-  }
-
-  max_depth = std::min(max_depth, kMaxStackTraceDepth);
-
-  std::vector<void*> raw_stack(max_depth);
-  // Skips the frames requested by the caller, plus this function.
-  const int raw_stack_size =
-      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
-
-  void* caller_frame = nullptr;
-  {
-    MutexLock lock(&mutex_);
-    caller_frame = caller_frame_;
-  }
-
-  for (int i = 0; i < raw_stack_size; ++i) {
-    if (raw_stack[i] == caller_frame &&
-        !GTEST_FLAG(show_internal_stack_frames)) {
-      // Add a marker to the trace and stop adding frames.
-      absl::StrAppend(&result, kElidedFramesMarker, "\n");
-      break;
-    }
-
-    char tmp[1024];
-    const char* symbol = "(unknown)";
-    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
-      symbol = tmp;
-    }
-
-    char line[1024];
-    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol);
-    result += line;
-  }
-
-  return result;
-
-#else  // !GTEST_HAS_ABSL
-  static_cast<void>(max_depth);
-  static_cast<void>(skip_count);
+// class OsStackTraceGetter 
+
+const char* const OsStackTraceGetterInterface::kElidedFramesMarker = 
+    "... " GTEST_NAME_ " internal frames ..."; 
+
+std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count) 
+    GTEST_LOCK_EXCLUDED_(mutex_) { 
+#if GTEST_HAS_ABSL 
+  std::string result; 
+
+  if (max_depth <= 0) { 
+    return result; 
+  } 
+
+  max_depth = std::min(max_depth, kMaxStackTraceDepth); 
+
+  std::vector<void*> raw_stack(max_depth); 
+  // Skips the frames requested by the caller, plus this function. 
+  const int raw_stack_size = 
+      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1); 
+
+  void* caller_frame = nullptr; 
+  { 
+    MutexLock lock(&mutex_); 
+    caller_frame = caller_frame_; 
+  } 
+
+  for (int i = 0; i < raw_stack_size; ++i) { 
+    if (raw_stack[i] == caller_frame && 
+        !GTEST_FLAG(show_internal_stack_frames)) { 
+      // Add a marker to the trace and stop adding frames. 
+      absl::StrAppend(&result, kElidedFramesMarker, "\n"); 
+      break; 
+    } 
+ 
+    char tmp[1024]; 
+    const char* symbol = "(unknown)"; 
+    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) { 
+      symbol = tmp; 
+    } 
+ 
+    char line[1024]; 
+    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol); 
+    result += line; 
+  } 
+ 
+  return result; 
+ 
+#else  // !GTEST_HAS_ABSL 
+  static_cast<void>(max_depth); 
+  static_cast<void>(skip_count); 
   return "";
-#endif  // GTEST_HAS_ABSL
+#endif  // GTEST_HAS_ABSL 
 }
 
-void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
-#if GTEST_HAS_ABSL
-  void* caller_frame = nullptr;
-  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
-    caller_frame = nullptr;
-  }
-
-  MutexLock lock(&mutex_);
-  caller_frame_ = caller_frame;
-#endif  // GTEST_HAS_ABSL
-}
+void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) { 
+#if GTEST_HAS_ABSL 
+  void* caller_frame = nullptr; 
+  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) { 
+    caller_frame = nullptr; 
+  } 
 
+  MutexLock lock(&mutex_); 
+  caller_frame_ = caller_frame; 
+#endif  // GTEST_HAS_ABSL 
+} 
+ 
 // A helper class that creates the premature-exit file in its
 // constructor and deletes the file in its destructor.
 class ScopedPrematureExitFile {
  public:
   explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
-      : premature_exit_filepath_(premature_exit_filepath ?
-                                 premature_exit_filepath : "") {
+      : premature_exit_filepath_(premature_exit_filepath ? 
+                                 premature_exit_filepath : "") { 
     // If a path to the premature-exit file is specified...
-    if (!premature_exit_filepath_.empty()) {
+    if (!premature_exit_filepath_.empty()) { 
       // create the file with a single "0" character in it.  I/O
       // errors are ignored as there's nothing better we can do and we
       // don't want to fail the test because of this.
@@ -5019,20 +5019,20 @@ class ScopedPrematureExitFile {
   }
 
   ~ScopedPrematureExitFile() {
-#if !defined GTEST_OS_ESP8266
-    if (!premature_exit_filepath_.empty()) {
-      int retval = remove(premature_exit_filepath_.c_str());
-      if (retval) {
-        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
-                          << premature_exit_filepath_ << "\" with error "
-                          << retval;
-      }
+#if !defined GTEST_OS_ESP8266 
+    if (!premature_exit_filepath_.empty()) { 
+      int retval = remove(premature_exit_filepath_.c_str()); 
+      if (retval) { 
+        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \"" 
+                          << premature_exit_filepath_ << "\" with error " 
+                          << retval; 
+      } 
     }
-#endif
+#endif 
   }
 
  private:
-  const std::string premature_exit_filepath_;
+  const std::string premature_exit_filepath_; 
 
   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
 };
@@ -5043,8 +5043,8 @@ class ScopedPrematureExitFile {
 
 TestEventListeners::TestEventListeners()
     : repeater_(new internal::TestEventRepeater()),
-      default_result_printer_(nullptr),
-      default_xml_generator_(nullptr) {}
+      default_result_printer_(nullptr), 
+      default_xml_generator_(nullptr) {} 
 
 TestEventListeners::~TestEventListeners() { delete repeater_; }
 
@@ -5061,9 +5061,9 @@ void TestEventListeners::Append(TestEventListener* listener) {
 // NULL if the listener is not found in the list.
 TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
   if (listener == default_result_printer_)
-    default_result_printer_ = nullptr;
+    default_result_printer_ = nullptr; 
   else if (listener == default_xml_generator_)
-    default_xml_generator_ = nullptr;
+    default_xml_generator_ = nullptr; 
   return repeater_->Release(listener);
 }
 
@@ -5082,7 +5082,7 @@ void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
     // list.
     delete Release(default_result_printer_);
     default_result_printer_ = listener;
-    if (listener != nullptr) Append(listener);
+    if (listener != nullptr) Append(listener); 
   }
 }
 
@@ -5097,7 +5097,7 @@ void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
     // list.
     delete Release(default_xml_generator_);
     default_xml_generator_ = listener;
-    if (listener != nullptr) Append(listener);
+    if (listener != nullptr) Append(listener); 
   }
 }
 
@@ -5125,62 +5125,62 @@ UnitTest* UnitTest::GetInstance() {
   // default implementation.  Use this implementation to keep good OO
   // design with private destructor.
 
-#if defined(__BORLANDC__)
+#if defined(__BORLANDC__) 
   static UnitTest* const instance = new UnitTest;
   return instance;
 #else
   static UnitTest instance;
   return &instance;
-#endif  // defined(__BORLANDC__)
+#endif  // defined(__BORLANDC__) 
 }
 
-// Gets the number of successful test suites.
-int UnitTest::successful_test_suite_count() const {
-  return impl()->successful_test_suite_count();
+// Gets the number of successful test suites. 
+int UnitTest::successful_test_suite_count() const { 
+  return impl()->successful_test_suite_count(); 
 }
 
-// Gets the number of failed test suites.
-int UnitTest::failed_test_suite_count() const {
-  return impl()->failed_test_suite_count();
+// Gets the number of failed test suites. 
+int UnitTest::failed_test_suite_count() const { 
+  return impl()->failed_test_suite_count(); 
 }
 
-// Gets the number of all test suites.
-int UnitTest::total_test_suite_count() const {
-  return impl()->total_test_suite_count();
+// Gets the number of all test suites. 
+int UnitTest::total_test_suite_count() const { 
+  return impl()->total_test_suite_count(); 
 }
 
-// Gets the number of all test suites that contain at least one test
+// Gets the number of all test suites that contain at least one test 
 // that should run.
-int UnitTest::test_suite_to_run_count() const {
-  return impl()->test_suite_to_run_count();
-}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-int UnitTest::successful_test_case_count() const {
-  return impl()->successful_test_suite_count();
-}
-int UnitTest::failed_test_case_count() const {
-  return impl()->failed_test_suite_count();
-}
-int UnitTest::total_test_case_count() const {
-  return impl()->total_test_suite_count();
-}
+int UnitTest::test_suite_to_run_count() const { 
+  return impl()->test_suite_to_run_count(); 
+} 
+ 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
+int UnitTest::successful_test_case_count() const { 
+  return impl()->successful_test_suite_count(); 
+} 
+int UnitTest::failed_test_case_count() const { 
+  return impl()->failed_test_suite_count(); 
+} 
+int UnitTest::total_test_case_count() const { 
+  return impl()->total_test_suite_count(); 
+} 
 int UnitTest::test_case_to_run_count() const {
-  return impl()->test_suite_to_run_count();
+  return impl()->test_suite_to_run_count(); 
 }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 
 // Gets the number of successful tests.
 int UnitTest::successful_test_count() const {
   return impl()->successful_test_count();
 }
 
-// Gets the number of skipped tests.
-int UnitTest::skipped_test_count() const {
-  return impl()->skipped_test_count();
-}
-
+// Gets the number of skipped tests. 
+int UnitTest::skipped_test_count() const { 
+  return impl()->skipped_test_count(); 
+} 
+ 
 // Gets the number of failed tests.
 int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
 
@@ -5216,37 +5216,37 @@ internal::TimeInMillis UnitTest::elapsed_time() const {
   return impl()->elapsed_time();
 }
 
-// Returns true if and only if the unit test passed (i.e. all test suites
-// passed).
+// Returns true if and only if the unit test passed (i.e. all test suites 
+// passed). 
 bool UnitTest::Passed() const { return impl()->Passed(); }
 
-// Returns true if and only if the unit test failed (i.e. some test suite
-// failed or something outside of all tests failed).
+// Returns true if and only if the unit test failed (i.e. some test suite 
+// failed or something outside of all tests failed). 
 bool UnitTest::Failed() const { return impl()->Failed(); }
 
-// 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* UnitTest::GetTestSuite(int i) const {
-  return impl()->GetTestSuite(i);
-}
-
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+// 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* UnitTest::GetTestSuite(int i) const { 
+  return impl()->GetTestSuite(i); 
+} 
+ 
+//  Legacy API is deprecated but still available 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 const TestCase* UnitTest::GetTestCase(int i) const {
   return impl()->GetTestCase(i);
 }
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 
 // Returns the TestResult containing information on test failures and
-// properties logged outside of individual test suites.
+// properties logged outside of individual test suites. 
 const TestResult& UnitTest::ad_hoc_test_result() const {
   return *impl()->ad_hoc_test_result();
 }
 
-// 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* UnitTest::GetMutableTestSuite(int i) {
-  return impl()->GetMutableSuiteCase(i);
+// 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* UnitTest::GetMutableTestSuite(int i) { 
+  return impl()->GetMutableSuiteCase(i); 
 }
 
 // Returns the list of event listeners that can be used to track events
@@ -5266,8 +5266,8 @@ TestEventListeners& UnitTest::listeners() {
 // We don't protect this under mutex_, as we only support calling it
 // from the main thread.
 Environment* UnitTest::AddEnvironment(Environment* env) {
-  if (env == nullptr) {
-    return nullptr;
+  if (env == nullptr) { 
+    return nullptr; 
   }
 
   impl_->environments().push_back(env);
@@ -5291,24 +5291,24 @@ void UnitTest::AddTestPartResult(
   if (impl_->gtest_trace_stack().size() > 0) {
     msg << "\n" << GTEST_NAME_ << " trace:";
 
-    for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
+    for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) { 
       const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
       msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
           << " " << trace.message;
     }
   }
 
-  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
+  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) { 
     msg << internal::kStackTraceMarker << os_stack_trace;
   }
 
-  const TestPartResult result = TestPartResult(
-      result_type, file_name, line_number, msg.GetString().c_str());
+  const TestPartResult result = TestPartResult( 
+      result_type, file_name, line_number, msg.GetString().c_str()); 
   impl_->GetTestPartResultReporterForCurrentThread()->
       ReportTestPartResult(result);
 
-  if (result_type != TestPartResult::kSuccess &&
-      result_type != TestPartResult::kSkip) {
+  if (result_type != TestPartResult::kSuccess && 
+      result_type != TestPartResult::kSkip) { 
     // gtest_break_on_failure takes precedence over
     // gtest_throw_on_failure.  This allows a user to set the latter
     // in the code (perhaps in order to use Google Test assertions
@@ -5320,16 +5320,16 @@ void UnitTest::AddTestPartResult(
       // when a failure happens and both the --gtest_break_on_failure and
       // the --gtest_catch_exceptions flags are specified.
       DebugBreak();
-#elif (!defined(__native_client__)) &&            \
-    ((defined(__clang__) || defined(__GNUC__)) && \
-     (defined(__x86_64__) || defined(__i386__)))
-      // with clang/gcc we can achieve the same effect on x86 by invoking int3
-      asm("int3");
+#elif (!defined(__native_client__)) &&            \ 
+    ((defined(__clang__) || defined(__GNUC__)) && \ 
+     (defined(__x86_64__) || defined(__i386__))) 
+      // with clang/gcc we can achieve the same effect on x86 by invoking int3 
+      asm("int3"); 
 #else
-      // Dereference nullptr through a volatile pointer to prevent the compiler
+      // Dereference nullptr through a volatile pointer to prevent the compiler 
       // from removing. We use this rather than abort() or __builtin_trap() for
-      // portability: some debuggers don't correctly trap abort().
-      *static_cast<volatile int*>(nullptr) = 1;
+      // portability: some debuggers don't correctly trap abort(). 
+      *static_cast<volatile int*>(nullptr) = 1; 
 #endif  // GTEST_OS_WINDOWS
     } else if (GTEST_FLAG(throw_on_failure)) {
 #if GTEST_HAS_EXCEPTIONS
@@ -5344,8 +5344,8 @@ void UnitTest::AddTestPartResult(
 }
 
 // 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
+// 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 UnitTest::RecordProperty(const std::string& key,
@@ -5384,15 +5384,15 @@ int UnitTest::Run() {
   // that understands the premature-exit-file protocol to report the
   // test as having failed.
   const internal::ScopedPrematureExitFile premature_exit_file(
-      in_death_test_child_process
-          ? nullptr
-          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+      in_death_test_child_process 
+          ? nullptr 
+          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); 
 
   // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
   // used for the duration of the program.
   impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
 
-#if GTEST_OS_WINDOWS
+#if GTEST_OS_WINDOWS 
   // Either the user wants Google Test to catch exceptions thrown by the
   // tests or this is executing in the context of death test child
   // process. In either case the user does not want to see pop-up dialogs
@@ -5411,7 +5411,7 @@ int UnitTest::Run() {
     _set_error_mode(_OUT_TO_STDERR);
 # endif
 
-# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
+# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE 
     // In the debug version, Visual Studio pops up a separate dialog
     // offering a choice to debug the aborted program. We need to suppress
     // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
@@ -5421,19 +5421,19 @@ int UnitTest::Run() {
       _set_abort_behavior(
           0x0,                                    // Clear the following flags:
           _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
-
-    // In debug mode, the Windows CRT can crash with an assertion over invalid
-    // input (e.g. passing an invalid file descriptor).  The default handling
-    // for these assertions is to pop up a dialog and wait for user input.
-    // Instead ask the CRT to dump such assertions to stderr non-interactively.
-    if (!IsDebuggerPresent()) {
-      (void)_CrtSetReportMode(_CRT_ASSERT,
-                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
-    }
-# endif
-  }
-#endif  // GTEST_OS_WINDOWS
+ 
+    // In debug mode, the Windows CRT can crash with an assertion over invalid 
+    // input (e.g. passing an invalid file descriptor).  The default handling 
+    // for these assertions is to pop up a dialog and wait for user input. 
+    // Instead ask the CRT to dump such assertions to stderr non-interactively. 
+    if (!IsDebuggerPresent()) { 
+      (void)_CrtSetReportMode(_CRT_ASSERT, 
+                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); 
+      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); 
+    } 
+# endif 
+  }
+#endif  // GTEST_OS_WINDOWS 
 
   return internal::HandleExceptionsInMethodIfSupported(
       impl(),
@@ -5447,22 +5447,22 @@ const char* UnitTest::original_working_dir() const {
   return impl_->original_working_dir_.c_str();
 }
 
-// Returns the TestSuite object for the test that's currently running,
+// Returns the TestSuite object for the test that's currently running, 
 // or NULL if no test is running.
-const TestSuite* UnitTest::current_test_suite() const
-    GTEST_LOCK_EXCLUDED_(mutex_) {
-  internal::MutexLock lock(&mutex_);
-  return impl_->current_test_suite();
-}
-
-// Legacy API is still available but deprecated
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+const TestSuite* UnitTest::current_test_suite() const 
+    GTEST_LOCK_EXCLUDED_(mutex_) { 
+  internal::MutexLock lock(&mutex_); 
+  return impl_->current_test_suite(); 
+} 
+ 
+// Legacy API is still available but deprecated 
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 
 const TestCase* UnitTest::current_test_case() const
     GTEST_LOCK_EXCLUDED_(mutex_) {
   internal::MutexLock lock(&mutex_);
-  return impl_->current_test_suite();
+  return impl_->current_test_suite(); 
 }
-#endif
+#endif 
 
 // Returns the TestInfo object for the test that's currently running,
 // or NULL if no test is running.
@@ -5475,10 +5475,10 @@ const TestInfo* UnitTest::current_test_info() const
 // Returns the random seed used at the start of the current test run.
 int UnitTest::random_seed() const { return impl_->random_seed(); }
 
-// Returns ParameterizedTestSuiteRegistry object used to keep track of
+// Returns ParameterizedTestSuiteRegistry object used to keep track of 
 // value-parameterized tests and instantiate and register them.
-internal::ParameterizedTestSuiteRegistry&
-UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
+internal::ParameterizedTestSuiteRegistry& 
+UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) { 
   return impl_->parameterized_test_registry();
 }
 
@@ -5512,22 +5512,22 @@ namespace internal {
 UnitTestImpl::UnitTestImpl(UnitTest* parent)
     : parent_(parent),
       GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
-          default_global_test_part_result_reporter_(this),
+          default_global_test_part_result_reporter_(this), 
       default_per_thread_test_part_result_reporter_(this),
-      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
+      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_( 
           &default_global_test_part_result_reporter_),
       per_thread_test_part_result_reporter_(
           &default_per_thread_test_part_result_reporter_),
       parameterized_test_registry_(),
       parameterized_tests_registered_(false),
-      last_death_test_suite_(-1),
-      current_test_suite_(nullptr),
-      current_test_info_(nullptr),
+      last_death_test_suite_(-1), 
+      current_test_suite_(nullptr), 
+      current_test_info_(nullptr), 
       ad_hoc_test_result_(),
-      os_stack_trace_getter_(nullptr),
+      os_stack_trace_getter_(nullptr), 
       post_flag_parse_init_performed_(false),
       random_seed_(0),  // Will be overridden by the flag before first use.
-      random_(0),       // Will be reseeded before first use.
+      random_(0),       // Will be reseeded before first use. 
       start_timestamp_(0),
       elapsed_time_(0),
 #if GTEST_HAS_DEATH_TEST
@@ -5539,8 +5539,8 @@ UnitTestImpl::UnitTestImpl(UnitTest* parent)
 }
 
 UnitTestImpl::~UnitTestImpl() {
-  // Deletes every TestSuite.
-  ForEach(test_suites_, internal::Delete<TestSuite>);
+  // Deletes every TestSuite. 
+  ForEach(test_suites_, internal::Delete<TestSuite>); 
 
   // Deletes every Environment.
   ForEach(environments_, internal::Delete<Environment>);
@@ -5549,20 +5549,20 @@ UnitTestImpl::~UnitTestImpl() {
 }
 
 // Adds a TestProperty to the current TestResult object when invoked in a
-// context of a test, to current test suite's ad_hoc_test_result when invoke
-// from SetUpTestSuite/TearDownTestSuite, or to the global property set
+// context of a test, to current test suite's ad_hoc_test_result when invoke 
+// from SetUpTestSuite/TearDownTestSuite, or to the global property set 
 // otherwise.  If the result already contains a property with the same key,
 // the value will be updated.
 void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
   std::string xml_element;
   TestResult* test_result;  // TestResult appropriate for property recording.
 
-  if (current_test_info_ != nullptr) {
+  if (current_test_info_ != nullptr) { 
     xml_element = "testcase";
     test_result = &(current_test_info_->result_);
-  } else if (current_test_suite_ != nullptr) {
+  } else if (current_test_suite_ != nullptr) { 
     xml_element = "testsuite";
-    test_result = &(current_test_suite_->ad_hoc_test_result_);
+    test_result = &(current_test_suite_->ad_hoc_test_result_); 
   } else {
     xml_element = "testsuites";
     test_result = &ad_hoc_test_result_;
@@ -5574,7 +5574,7 @@ void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
 // Disables event forwarding if the control is currently in a death test
 // subprocess. Must not be called before InitGoogleTest.
 void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
-  if (internal_run_death_test_flag_.get() != nullptr)
+  if (internal_run_death_test_flag_.get() != nullptr) 
     listeners()->SuppressEventForwarding();
 }
 #endif  // GTEST_HAS_DEATH_TEST
@@ -5586,12 +5586,12 @@ void UnitTestImpl::ConfigureXmlOutput() {
   if (output_format == "xml") {
     listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
         UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
-  } else if (output_format == "json") {
-    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format == "json") { 
+    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter( 
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 
   } else if (output_format != "") {
-    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
-                        << output_format << "\" ignored.";
+    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" 
+                        << output_format << "\" ignored."; 
   }
 }
 
@@ -5606,8 +5606,8 @@ void UnitTestImpl::ConfigureStreamingOutput() {
       listeners()->Append(new StreamingListener(target.substr(0, pos),
                                                 target.substr(pos+1)));
     } else {
-      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
-                          << "\" ignored.";
+      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target 
+                          << "\" ignored."; 
     }
   }
 }
@@ -5642,91 +5642,91 @@ void UnitTestImpl::PostFlagParsingInit() {
     // to shut down the default XML output before invoking RUN_ALL_TESTS.
     ConfigureXmlOutput();
 
-    if (GTEST_FLAG(brief)) {
-      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
-    }
-
+    if (GTEST_FLAG(brief)) { 
+      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter); 
+    } 
+ 
 #if GTEST_CAN_STREAM_RESULTS_
     // Configures listeners for streaming test results to the specified server.
     ConfigureStreamingOutput();
 #endif  // GTEST_CAN_STREAM_RESULTS_
-
-#if GTEST_HAS_ABSL
-    if (GTEST_FLAG(install_failure_signal_handler)) {
-      absl::FailureSignalHandlerOptions options;
-      absl::InstallFailureSignalHandler(options);
-    }
-#endif  // GTEST_HAS_ABSL
+ 
+#if GTEST_HAS_ABSL 
+    if (GTEST_FLAG(install_failure_signal_handler)) { 
+      absl::FailureSignalHandlerOptions options; 
+      absl::InstallFailureSignalHandler(options); 
+    } 
+#endif  // GTEST_HAS_ABSL 
   }
 }
 
-// A predicate that checks the name of a TestSuite against a known
+// A predicate that checks the name of a TestSuite against a known 
 // value.
 //
 // This is used for implementation of the UnitTest class only.  We put
 // it in the anonymous namespace to prevent polluting the outer
 // namespace.
 //
-// TestSuiteNameIs is copyable.
-class TestSuiteNameIs {
+// TestSuiteNameIs is copyable. 
+class TestSuiteNameIs { 
  public:
   // Constructor.
-  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
+  explicit TestSuiteNameIs(const std::string& name) : name_(name) {} 
 
-  // Returns true if and only if the name of test_suite matches name_.
-  bool operator()(const TestSuite* test_suite) const {
-    return test_suite != nullptr &&
-           strcmp(test_suite->name(), name_.c_str()) == 0;
+  // Returns true if and only if the name of test_suite matches name_. 
+  bool operator()(const TestSuite* test_suite) const { 
+    return test_suite != nullptr && 
+           strcmp(test_suite->name(), name_.c_str()) == 0; 
   }
 
  private:
   std::string name_;
 };
 
-// Finds and returns a TestSuite with the given name.  If one doesn't
+// Finds and returns a TestSuite with the given name.  If one doesn't 
 // exist, creates one and returns it.  It's the CALLER'S
 // RESPONSIBILITY to ensure that this function is only called WHEN THE
 // TESTS ARE NOT SHUFFLED.
 //
 // Arguments:
 //
-//   test_suite_name: name of the test suite
-//   type_param:      the name of the test suite's type parameter, or NULL if
-//                    this is not a typed or a type-parameterized test suite.
-//   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* UnitTestImpl::GetTestSuite(
-    const char* test_suite_name, const char* type_param,
-    internal::SetUpTestSuiteFunc set_up_tc,
-    internal::TearDownTestSuiteFunc tear_down_tc) {
-  // Can we find a TestSuite with the given name?
-  const auto test_suite =
-      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
-                   TestSuiteNameIs(test_suite_name));
-
-  if (test_suite != test_suites_.rend()) return *test_suite;
+//   test_suite_name: name of the test suite 
+//   type_param:      the name of the test suite's type parameter, or NULL if 
+//                    this is not a typed or a type-parameterized test suite. 
+//   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* UnitTestImpl::GetTestSuite( 
+    const char* test_suite_name, const char* type_param, 
+    internal::SetUpTestSuiteFunc set_up_tc, 
+    internal::TearDownTestSuiteFunc tear_down_tc) { 
+  // Can we find a TestSuite with the given name? 
+  const auto test_suite = 
+      std::find_if(test_suites_.rbegin(), test_suites_.rend(), 
+                   TestSuiteNameIs(test_suite_name)); 
+
+  if (test_suite != test_suites_.rend()) return *test_suite; 
 
   // No.  Let's create one.
-  auto* const new_test_suite =
-      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
-
-  // Is this a death test suite?
-  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
-                                               kDeathTestSuiteFilter)) {
-    // Yes.  Inserts the test suite after the last death test suite
-    // defined so far.  This only works when the test suites haven't
+  auto* const new_test_suite = 
+      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc); 
+
+  // Is this a death test suite? 
+  if (internal::UnitTestOptions::MatchesFilter(test_suite_name, 
+                                               kDeathTestSuiteFilter)) { 
+    // Yes.  Inserts the test suite after the last death test suite 
+    // defined so far.  This only works when the test suites haven't 
     // been shuffled.  Otherwise we may end up running a death test
     // after a non-death test.
-    ++last_death_test_suite_;
-    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
-                        new_test_suite);
+    ++last_death_test_suite_; 
+    test_suites_.insert(test_suites_.begin() + last_death_test_suite_, 
+                        new_test_suite); 
   } else {
     // No.  Appends to the end of the list.
-    test_suites_.push_back(new_test_suite);
+    test_suites_.push_back(new_test_suite); 
   }
 
-  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
-  return new_test_suite;
+  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size())); 
+  return new_test_suite; 
 }
 
 // Helpers for setting up / tearing down the given environment.  They
@@ -5744,9 +5744,9 @@ static void TearDownEnvironment(Environment* env) { env->TearDown(); }
 // All other functions called from RunAllTests() may safely assume that
 // parameterized tests are ready to be counted and run.
 bool UnitTestImpl::RunAllTests() {
-  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
-  // called.
-  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
+  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is 
+  // called. 
+  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized(); 
 
   // Do not run any test if the --help flag was specified.
   if (g_help_flag)
@@ -5761,13 +5761,13 @@ bool UnitTestImpl::RunAllTests() {
   // protocol.
   internal::WriteToShardStatusFileIfNeeded();
 
-  // True if and only if we are in a subprocess for running a thread-safe-style
+  // True if and only if we are in a subprocess for running a thread-safe-style 
   // death test.
   bool in_subprocess_for_death_test = false;
 
 #if GTEST_HAS_DEATH_TEST
-  in_subprocess_for_death_test =
-      (internal_run_death_test_flag_.get() != nullptr);
+  in_subprocess_for_death_test = 
+      (internal_run_death_test_flag_.get() != nullptr); 
 # if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
   if (in_subprocess_for_death_test) {
     GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
@@ -5794,7 +5794,7 @@ bool UnitTestImpl::RunAllTests() {
   random_seed_ = GTEST_FLAG(shuffle) ?
       GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
 
-  // True if and only if at least one test has failed.
+  // True if and only if at least one test has failed. 
   bool failed = false;
 
   TestEventListener* repeater = listeners()->repeater();
@@ -5806,17 +5806,17 @@ bool UnitTestImpl::RunAllTests() {
   // when we are inside the subprocess of a death test.
   const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
   // Repeats forever if the repeat count is negative.
-  const bool gtest_repeat_forever = repeat < 0;
-  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
+  const bool gtest_repeat_forever = repeat < 0; 
+  for (int i = 0; gtest_repeat_forever || i != repeat; i++) { 
     // We want to preserve failures generated by ad-hoc test
     // assertions executed before RUN_ALL_TESTS().
     ClearNonAdHocTestResult();
 
-    Timer timer;
+    Timer timer; 
 
-    // Shuffles test suites and tests if requested.
+    // Shuffles test suites and tests if requested. 
     if (has_tests_to_run && GTEST_FLAG(shuffle)) {
-      random()->Reseed(static_cast<uint32_t>(random_seed_));
+      random()->Reseed(static_cast<uint32_t>(random_seed_)); 
       // This should be done before calling OnTestIterationStart(),
       // such that a test event listener can see the actual test order
       // in the event.
@@ -5826,49 +5826,49 @@ bool UnitTestImpl::RunAllTests() {
     // Tells the unit test event listeners that the tests are about to start.
     repeater->OnTestIterationStart(*parent_, i);
 
-    // Runs each test suite if there is at least one test to run.
+    // Runs each test suite if there is at least one test to run. 
     if (has_tests_to_run) {
       // Sets up all environments beforehand.
       repeater->OnEnvironmentsSetUpStart(*parent_);
       ForEach(environments_, SetUpEnvironment);
       repeater->OnEnvironmentsSetUpEnd(*parent_);
 
-      // Runs the tests only if there was no fatal failure or skip triggered
-      // during global set-up.
-      if (Test::IsSkipped()) {
-        // Emit diagnostics when global set-up calls skip, as it will not be
-        // emitted by default.
-        TestResult& test_result =
-            *internal::GetUnitTestImpl()->current_test_result();
-        for (int j = 0; j < test_result.total_part_count(); ++j) {
-          const TestPartResult& test_part_result =
-              test_result.GetTestPartResult(j);
-          if (test_part_result.type() == TestPartResult::kSkip) {
-            const std::string& result = test_part_result.message();
-            printf("%s\n", result.c_str());
-          }
-        }
-        fflush(stdout);
-      } else if (!Test::HasFatalFailure()) {
-        for (int test_index = 0; test_index < total_test_suite_count();
-             test_index++) {
-          GetMutableSuiteCase(test_index)->Run();
-          if (GTEST_FLAG(fail_fast) &&
-              GetMutableSuiteCase(test_index)->Failed()) {
-            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
-              GetMutableSuiteCase(j)->Skip();
-            }
-            break;
-          }
-        }
-      } else if (Test::HasFatalFailure()) {
-        // If there was a fatal failure during the global setup then we know we
-        // aren't going to run any tests. Explicitly mark all of the tests as
-        // skipped to make this obvious in the output.
-        for (int test_index = 0; test_index < total_test_suite_count();
+      // Runs the tests only if there was no fatal failure or skip triggered 
+      // during global set-up. 
+      if (Test::IsSkipped()) { 
+        // Emit diagnostics when global set-up calls skip, as it will not be 
+        // emitted by default. 
+        TestResult& test_result = 
+            *internal::GetUnitTestImpl()->current_test_result(); 
+        for (int j = 0; j < test_result.total_part_count(); ++j) { 
+          const TestPartResult& test_part_result = 
+              test_result.GetTestPartResult(j); 
+          if (test_part_result.type() == TestPartResult::kSkip) { 
+            const std::string& result = test_part_result.message(); 
+            printf("%s\n", result.c_str()); 
+          } 
+        } 
+        fflush(stdout); 
+      } else if (!Test::HasFatalFailure()) { 
+        for (int test_index = 0; test_index < total_test_suite_count(); 
              test_index++) {
-          GetMutableSuiteCase(test_index)->Skip();
+          GetMutableSuiteCase(test_index)->Run(); 
+          if (GTEST_FLAG(fail_fast) && 
+              GetMutableSuiteCase(test_index)->Failed()) { 
+            for (int j = test_index + 1; j < total_test_suite_count(); j++) { 
+              GetMutableSuiteCase(j)->Skip(); 
+            } 
+            break; 
+          } 
         }
+      } else if (Test::HasFatalFailure()) { 
+        // If there was a fatal failure during the global setup then we know we 
+        // aren't going to run any tests. Explicitly mark all of the tests as 
+        // skipped to make this obvious in the output. 
+        for (int test_index = 0; test_index < total_test_suite_count(); 
+             test_index++) { 
+          GetMutableSuiteCase(test_index)->Skip(); 
+        } 
       }
 
       // Tears down all environments in reverse order afterwards.
@@ -5878,7 +5878,7 @@ bool UnitTestImpl::RunAllTests() {
       repeater->OnEnvironmentsTearDownEnd(*parent_);
     }
 
-    elapsed_time_ = timer.Elapsed();
+    elapsed_time_ = timer.Elapsed(); 
 
     // Tells the unit test event listener that the tests have just finished.
     repeater->OnTestIterationEnd(*parent_, i);
@@ -5904,20 +5904,20 @@ bool UnitTestImpl::RunAllTests() {
 
   repeater->OnTestProgramEnd(*parent_);
 
-  if (!gtest_is_initialized_before_run_all_tests) {
-    ColoredPrintf(
-        GTestColor::kRed,
-        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
-        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
-        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
-        " will start to enforce the valid usage. "
-        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
-#if GTEST_FOR_GOOGLE_
-    ColoredPrintf(GTestColor::kRed,
-                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
-#endif  // GTEST_FOR_GOOGLE_
-  }
-
+  if (!gtest_is_initialized_before_run_all_tests) { 
+    ColoredPrintf( 
+        GTestColor::kRed, 
+        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n" 
+        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_ 
+        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_ 
+        " will start to enforce the valid usage. " 
+        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT 
+#if GTEST_FOR_GOOGLE_ 
+    ColoredPrintf(GTestColor::kRed, 
+                  "For more details, see http://wiki/Main/ValidGUnitMain.\n"); 
+#endif  // GTEST_FOR_GOOGLE_ 
+  } 
+ 
   return !failed;
 }
 
@@ -5927,10 +5927,10 @@ bool UnitTestImpl::RunAllTests() {
 // be created, prints an error and exits.
 void WriteToShardStatusFileIfNeeded() {
   const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
-  if (test_shard_file != nullptr) {
+  if (test_shard_file != nullptr) { 
     FILE* const file = posix::FOpen(test_shard_file, "w");
-    if (file == nullptr) {
-      ColoredPrintf(GTestColor::kRed,
+    if (file == nullptr) { 
+      ColoredPrintf(GTestColor::kRed, 
                     "Could not write to the test shard status file \"%s\" "
                     "specified by the %s environment variable.\n",
                     test_shard_file, kTestShardStatusFile);
@@ -5954,8 +5954,8 @@ bool ShouldShard(const char* total_shards_env,
     return false;
   }
 
-  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
-  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
+  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1); 
+  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1); 
 
   if (total_shards == -1 && shard_index == -1) {
     return false;
@@ -5964,7 +5964,7 @@ bool ShouldShard(const char* total_shards_env,
       << "Invalid environment variables: you have "
       << kTestShardIndex << " = " << shard_index
       << ", but have left " << kTestTotalShards << " unset.\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (total_shards != -1 && shard_index == -1) {
@@ -5972,7 +5972,7 @@ bool ShouldShard(const char* total_shards_env,
       << "Invalid environment variables: you have "
       << kTestTotalShards << " = " << total_shards
       << ", but have left " << kTestShardIndex << " unset.\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (shard_index < 0 || shard_index >= total_shards) {
@@ -5981,7 +5981,7 @@ bool ShouldShard(const char* total_shards_env,
       << kTestShardIndex << " < " << kTestTotalShards
       << ", but you have " << kTestShardIndex << "=" << shard_index
       << ", " << kTestTotalShards << "=" << total_shards << ".\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 
     fflush(stdout);
     exit(EXIT_FAILURE);
   }
@@ -5992,13 +5992,13 @@ bool ShouldShard(const char* total_shards_env,
 // Parses the environment variable var as an Int32. If it is unset,
 // returns default_val. If it is not an Int32, prints an error
 // and aborts.
-int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
+int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) { 
   const char* str_val = posix::GetEnv(var);
-  if (str_val == nullptr) {
+  if (str_val == nullptr) { 
     return default_val;
   }
 
-  int32_t result;
+  int32_t result; 
   if (!ParseInt32(Message() << "The value of environment variable " << var,
                   str_val, &result)) {
     exit(EXIT_FAILURE);
@@ -6007,8 +6007,8 @@ int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
 }
 
 // Given the total number of shards, the shard index, and the test id,
-// returns true if and only if the test should be run on this shard. The test id
-// is some arbitrary but unique non-negative integer assigned to each test
+// returns true if and only if the test should be run on this shard. The test id 
+// is some arbitrary but unique non-negative integer assigned to each test 
 // method. Assumes that 0 <= shard_index < total_shards.
 bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
   return (test_id % total_shards) == shard_index;
@@ -6016,15 +6016,15 @@ bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
 
 // Compares the name of each test with the user-specified filter to
 // decide whether the test should be run, then records the result in
-// each TestSuite and TestInfo object.
+// each TestSuite and TestInfo object. 
 // If shard_tests == true, further filters tests based on sharding
 // variables in the environment - see
-// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
-// . Returns the number of tests that should run.
+// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md 
+// . Returns the number of tests that should run. 
 int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
-  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
+  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? 
       Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
-  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
+  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? 
       Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
 
   // num_runnable_tests are the number of tests that will
@@ -6033,40 +6033,40 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
   // this shard.
   int num_runnable_tests = 0;
   int num_selected_tests = 0;
-  for (auto* test_suite : test_suites_) {
-    const std::string& test_suite_name = test_suite->name();
-    test_suite->set_should_run(false);
+  for (auto* test_suite : test_suites_) { 
+    const std::string& test_suite_name = test_suite->name(); 
+    test_suite->set_should_run(false); 
 
-    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
-      TestInfo* const test_info = test_suite->test_info_list()[j];
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { 
+      TestInfo* const test_info = test_suite->test_info_list()[j]; 
       const std::string test_name(test_info->name());
-      // A test is disabled if test suite name or test name matches
+      // A test is disabled if test suite name or test name matches 
       // kDisableTestFilter.
-      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
-                                   test_suite_name, kDisableTestFilter) ||
-                               internal::UnitTestOptions::MatchesFilter(
-                                   test_name, kDisableTestFilter);
+      const bool is_disabled = internal::UnitTestOptions::MatchesFilter( 
+                                   test_suite_name, kDisableTestFilter) || 
+                               internal::UnitTestOptions::MatchesFilter( 
+                                   test_name, kDisableTestFilter); 
       test_info->is_disabled_ = is_disabled;
 
-      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
-          test_suite_name, test_name);
+      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest( 
+          test_suite_name, test_name); 
       test_info->matches_filter_ = matches_filter;
 
       const bool is_runnable =
           (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
           matches_filter;
 
-      const bool is_in_another_shard =
-          shard_tests != IGNORE_SHARDING_PROTOCOL &&
-          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
-      test_info->is_in_another_shard_ = is_in_another_shard;
-      const bool is_selected = is_runnable && !is_in_another_shard;
+      const bool is_in_another_shard = 
+          shard_tests != IGNORE_SHARDING_PROTOCOL && 
+          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests); 
+      test_info->is_in_another_shard_ = is_in_another_shard; 
+      const bool is_selected = is_runnable && !is_in_another_shard; 
 
       num_runnable_tests += is_runnable;
       num_selected_tests += is_selected;
 
       test_info->should_run_ = is_selected;
-      test_suite->set_should_run(test_suite->should_run() || is_selected);
+      test_suite->set_should_run(test_suite->should_run() || is_selected); 
     }
   }
   return num_selected_tests;
@@ -6077,7 +6077,7 @@ int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
 // max_length characters, only prints the first max_length characters
 // and "...".
 static void PrintOnOneLine(const char* str, int max_length) {
-  if (str != nullptr) {
+  if (str != nullptr) { 
     for (int i = 0; *str != '\0'; ++str) {
       if (i >= max_length) {
         printf("...");
@@ -6099,25 +6099,25 @@ void UnitTestImpl::ListTestsMatchingFilter() {
   // Print at most this many characters for each type/value parameter.
   const int kMaxParamLength = 250;
 
-  for (auto* test_suite : test_suites_) {
-    bool printed_test_suite_name = false;
+  for (auto* test_suite : test_suites_) { 
+    bool printed_test_suite_name = false; 
 
-    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
-      const TestInfo* const test_info = test_suite->test_info_list()[j];
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { 
+      const TestInfo* const test_info = test_suite->test_info_list()[j]; 
       if (test_info->matches_filter_) {
-        if (!printed_test_suite_name) {
-          printed_test_suite_name = true;
-          printf("%s.", test_suite->name());
-          if (test_suite->type_param() != nullptr) {
+        if (!printed_test_suite_name) { 
+          printed_test_suite_name = true; 
+          printf("%s.", test_suite->name()); 
+          if (test_suite->type_param() != nullptr) { 
             printf("  # %s = ", kTypeParamLabel);
             // We print the type parameter on a single line to make
             // the output easy to parse by a program.
-            PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
+            PrintOnOneLine(test_suite->type_param(), kMaxParamLength); 
           }
           printf("\n");
         }
         printf("  %s", test_info->name());
-        if (test_info->value_param() != nullptr) {
+        if (test_info->value_param() != nullptr) { 
           printf("  # %s = ", kValueParamLabel);
           // We print the value parameter on a single line to make the
           // output easy to parse by a program.
@@ -6128,23 +6128,23 @@ void UnitTestImpl::ListTestsMatchingFilter() {
     }
   }
   fflush(stdout);
-  const std::string& output_format = UnitTestOptions::GetOutputFormat();
-  if (output_format == "xml" || output_format == "json") {
-    FILE* fileout = OpenFileForWriting(
-        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
-    std::stringstream stream;
-    if (output_format == "xml") {
-      XmlUnitTestResultPrinter(
-          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
-          .PrintXmlTestsList(&stream, test_suites_);
-    } else if (output_format == "json") {
-      JsonUnitTestResultPrinter(
-          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
-          .PrintJsonTestList(&stream, test_suites_);
-    }
-    fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
-    fclose(fileout);
-  }
+  const std::string& output_format = UnitTestOptions::GetOutputFormat(); 
+  if (output_format == "xml" || output_format == "json") { 
+    FILE* fileout = OpenFileForWriting( 
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()); 
+    std::stringstream stream; 
+    if (output_format == "xml") { 
+      XmlUnitTestResultPrinter( 
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) 
+          .PrintXmlTestsList(&stream, test_suites_); 
+    } else if (output_format == "json") { 
+      JsonUnitTestResultPrinter( 
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str()) 
+          .PrintJsonTestList(&stream, test_suites_); 
+    } 
+    fprintf(fileout, "%s", StringStreamToString(&stream).c_str()); 
+    fclose(fileout); 
+  } 
 }
 
 // Sets the OS stack trace getter.
@@ -6164,7 +6164,7 @@ void UnitTestImpl::set_os_stack_trace_getter(
 // otherwise, creates an OsStackTraceGetter, makes it the current
 // getter, and returns it.
 OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
-  if (os_stack_trace_getter_ == nullptr) {
+  if (os_stack_trace_getter_ == nullptr) { 
 #ifdef GTEST_OS_STACK_TRACE_GETTER_
     os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
 #else
@@ -6175,40 +6175,40 @@ OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
   return os_stack_trace_getter_;
 }
 
-// Returns the most specific TestResult currently running.
+// Returns the most specific TestResult currently running. 
 TestResult* UnitTestImpl::current_test_result() {
-  if (current_test_info_ != nullptr) {
-    return &current_test_info_->result_;
-  }
-  if (current_test_suite_ != nullptr) {
-    return &current_test_suite_->ad_hoc_test_result_;
-  }
-  return &ad_hoc_test_result_;
+  if (current_test_info_ != nullptr) { 
+    return &current_test_info_->result_; 
+  } 
+  if (current_test_suite_ != nullptr) { 
+    return &current_test_suite_->ad_hoc_test_result_; 
+  } 
+  return &ad_hoc_test_result_; 
 }
 
-// Shuffles all test suites, and the tests within each test suite,
+// Shuffles all test suites, and the tests within each test suite, 
 // making sure that death tests are still run first.
 void UnitTestImpl::ShuffleTests() {
-  // Shuffles the death test suites.
-  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
+  // Shuffles the death test suites. 
+  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_); 
 
-  // Shuffles the non-death test suites.
-  ShuffleRange(random(), last_death_test_suite_ + 1,
-               static_cast<int>(test_suites_.size()), &test_suite_indices_);
+  // Shuffles the non-death test suites. 
+  ShuffleRange(random(), last_death_test_suite_ + 1, 
+               static_cast<int>(test_suites_.size()), &test_suite_indices_); 
 
-  // Shuffles the tests inside each test suite.
-  for (auto& test_suite : test_suites_) {
-    test_suite->ShuffleTests(random());
+  // Shuffles the tests inside each test suite. 
+  for (auto& test_suite : test_suites_) { 
+    test_suite->ShuffleTests(random()); 
   }
 }
 
-// Restores the test suites and tests to their order before the first shuffle.
+// Restores the test suites and tests to their order before the first shuffle. 
 void UnitTestImpl::UnshuffleTests() {
-  for (size_t i = 0; i < test_suites_.size(); i++) {
-    // Unshuffles the tests in each test suite.
-    test_suites_[i]->UnshuffleTests();
-    // Resets the index of each test suite.
-    test_suite_indices_[i] = static_cast<int>(i);
+  for (size_t i = 0; i < test_suites_.size(); i++) { 
+    // Unshuffles the tests in each test suite. 
+    test_suites_[i]->UnshuffleTests(); 
+    // Resets the index of each test suite. 
+    test_suite_indices_[i] = static_cast<int>(i); 
   }
 }
 
@@ -6264,15 +6264,15 @@ bool SkipPrefix(const char* prefix, const char** pstr) {
 // part can be omitted.
 //
 // Returns the value of the flag, or NULL if the parsing failed.
-static const char* ParseFlagValue(const char* str, const char* flag,
-                                  bool def_optional) {
+static const char* ParseFlagValue(const char* str, const char* flag, 
+                                  bool def_optional) { 
   // str and flag must not be NULL.
-  if (str == nullptr || flag == nullptr) return nullptr;
+  if (str == nullptr || flag == nullptr) return nullptr; 
 
   // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
   const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
   const size_t flag_len = flag_str.length();
-  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; 
 
   // Skips the flag name.
   const char* flag_end = str + flag_len;
@@ -6285,7 +6285,7 @@ static const char* ParseFlagValue(const char* str, const char* flag,
   // If def_optional is true and there are more characters after the
   // flag name, or if def_optional is false, there must be a '=' after
   // the flag name.
-  if (flag_end[0] != '=') return nullptr;
+  if (flag_end[0] != '=') return nullptr; 
 
   // Returns the string after "=".
   return flag_end + 1;
@@ -6301,45 +6301,45 @@ static const char* ParseFlagValue(const char* str, const char* flag,
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+static bool ParseBoolFlag(const char* str, const char* flag, bool* value) { 
   // Gets the value of the flag as a string.
   const char* const value_str = ParseFlagValue(str, flag, true);
 
   // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
+  if (value_str == nullptr) return false; 
 
   // Converts the string value to a bool.
   *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
   return true;
 }
 
-// Parses a string for an int32_t flag, in the form of "--flag=value".
+// Parses a string for an int32_t flag, in the form of "--flag=value". 
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
+bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) { 
   // Gets the value of the flag as a string.
   const char* const value_str = ParseFlagValue(str, flag, false);
 
   // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
+  if (value_str == nullptr) return false; 
 
   // Sets *value to the value of the flag.
   return ParseInt32(Message() << "The value of flag --" << flag,
                     value_str, value);
 }
 
-// Parses a string for a string flag, in the form of "--flag=value".
+// Parses a string for a string flag, in the form of "--flag=value". 
 //
 // On success, stores the value of the flag in *value, and returns
 // true.  On failure, returns false without changing *value.
-template <typename String>
-static bool ParseStringFlag(const char* str, const char* flag, String* value) {
+template <typename String> 
+static bool ParseStringFlag(const char* str, const char* flag, String* value) { 
   // Gets the value of the flag as a string.
   const char* const value_str = ParseFlagValue(str, flag, false);
 
   // Aborts if the parsing failed.
-  if (value_str == nullptr) return false;
+  if (value_str == nullptr) return false; 
 
   // Sets *value to the value of the flag.
   *value = value_str;
@@ -6371,7 +6371,7 @@ static bool HasGoogleTestFlagPrefix(const char* str) {
 //   @D    changes to the default terminal text color.
 //
 static void PrintColorEncoded(const char* str) {
-  GTestColor color = GTestColor::kDefault;  // The current color.
+  GTestColor color = GTestColor::kDefault;  // The current color. 
 
   // Conceptually, we split the string into segments divided by escape
   // sequences.  Then we print one segment at a time.  At the end of
@@ -6379,7 +6379,7 @@ static void PrintColorEncoded(const char* str) {
   // next segment.
   for (;;) {
     const char* p = strchr(str, '@');
-    if (p == nullptr) {
+    if (p == nullptr) { 
       ColoredPrintf(color, "%s", str);
       return;
     }
@@ -6391,13 +6391,13 @@ static void PrintColorEncoded(const char* str) {
     if (ch == '@') {
       ColoredPrintf(color, "@");
     } else if (ch == 'D') {
-      color = GTestColor::kDefault;
+      color = GTestColor::kDefault; 
     } else if (ch == 'R') {
-      color = GTestColor::kRed;
+      color = GTestColor::kRed; 
     } else if (ch == 'G') {
-      color = GTestColor::kGreen;
+      color = GTestColor::kGreen; 
     } else if (ch == 'Y') {
-      color = GTestColor::kYellow;
+      color = GTestColor::kYellow; 
     } else {
       --str;
     }
@@ -6405,134 +6405,134 @@ static void PrintColorEncoded(const char* str) {
 }
 
 static const char kColorEncodedHelpMessage[] =
-    "This program contains tests written using " GTEST_NAME_
-    ". You can use the\n"
-    "following command line flags to control its behavior:\n"
-    "\n"
-    "Test Selection:\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "list_tests@D\n"
-    "      List the names of all tests instead of running them. The name of\n"
-    "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "filter=@YPOSITIVE_PATTERNS"
+    "This program contains tests written using " GTEST_NAME_ 
+    ". You can use the\n" 
+    "following command line flags to control its behavior:\n" 
+    "\n" 
+    "Test Selection:\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "list_tests@D\n" 
+    "      List the names of all tests instead of running them. The name of\n" 
+    "      TEST(Foo, Bar) is \"Foo.Bar\".\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "filter=@YPOSITIVE_PATTERNS" 
     "[@G-@YNEGATIVE_PATTERNS]@D\n"
-    "      Run only the tests whose name matches one of the positive patterns "
-    "but\n"
-    "      none of the negative patterns. '?' matches any single character; "
-    "'*'\n"
-    "      matches any substring; ':' separates two patterns.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "also_run_disabled_tests@D\n"
-    "      Run all disabled tests too.\n"
-    "\n"
-    "Test Execution:\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "repeat=@Y[COUNT]@D\n"
-    "      Run the tests repeatedly; use a negative count to repeat forever.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "shuffle@D\n"
-    "      Randomize tests' orders on every iteration.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "random_seed=@Y[NUMBER]@D\n"
-    "      Random number seed to use for shuffling test orders (between 1 and\n"
-    "      99999, or 0 to use a seed based on the current time).\n"
-    "\n"
-    "Test Output:\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
-    "      Enable/disable colored output. The default is @Gauto@D.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "brief=1@D\n"
-    "      Only print test failures.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "print_time=0@D\n"
-    "      Don't print the elapsed time of each test.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
-    "@Y|@G:@YFILE_PATH]@D\n"
-    "      Generate a JSON or XML report in the given directory or with the "
-    "given\n"
-    "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
-# if GTEST_CAN_STREAM_RESULTS_
-    "  @G--" GTEST_FLAG_PREFIX_
-    "stream_result_to=@YHOST@G:@YPORT@D\n"
-    "      Stream test results to the given server.\n"
-# endif  // GTEST_CAN_STREAM_RESULTS_
-    "\n"
-    "Assertion Behavior:\n"
-# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-    "  @G--" GTEST_FLAG_PREFIX_
-    "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
-    "      Set the default death test style.\n"
-# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
-    "  @G--" GTEST_FLAG_PREFIX_
-    "break_on_failure@D\n"
-    "      Turn assertion failures into debugger break-points.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "throw_on_failure@D\n"
-    "      Turn assertion failures into C++ exceptions for use by an external\n"
-    "      test framework.\n"
-    "  @G--" GTEST_FLAG_PREFIX_
-    "catch_exceptions=0@D\n"
-    "      Do not report exceptions as test failures. Instead, allow them\n"
-    "      to crash the program or throw a pop-up (on Windows).\n"
-    "\n"
-    "Except for @G--" GTEST_FLAG_PREFIX_
-    "list_tests@D, you can alternatively set "
+    "      Run only the tests whose name matches one of the positive patterns " 
+    "but\n" 
+    "      none of the negative patterns. '?' matches any single character; " 
+    "'*'\n" 
+    "      matches any substring; ':' separates two patterns.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "also_run_disabled_tests@D\n" 
+    "      Run all disabled tests too.\n" 
+    "\n" 
+    "Test Execution:\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "repeat=@Y[COUNT]@D\n" 
+    "      Run the tests repeatedly; use a negative count to repeat forever.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "shuffle@D\n" 
+    "      Randomize tests' orders on every iteration.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "random_seed=@Y[NUMBER]@D\n" 
+    "      Random number seed to use for shuffling test orders (between 1 and\n" 
+    "      99999, or 0 to use a seed based on the current time).\n" 
+    "\n" 
+    "Test Output:\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" 
+    "      Enable/disable colored output. The default is @Gauto@D.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "brief=1@D\n" 
+    "      Only print test failures.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "print_time=0@D\n" 
+    "      Don't print the elapsed time of each test.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_ 
+    "@Y|@G:@YFILE_PATH]@D\n" 
+    "      Generate a JSON or XML report in the given directory or with the " 
+    "given\n" 
+    "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n" 
+# if GTEST_CAN_STREAM_RESULTS_ 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "stream_result_to=@YHOST@G:@YPORT@D\n" 
+    "      Stream test results to the given server.\n" 
+# endif  // GTEST_CAN_STREAM_RESULTS_ 
+    "\n" 
+    "Assertion Behavior:\n" 
+# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" 
+    "      Set the default death test style.\n" 
+# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "break_on_failure@D\n" 
+    "      Turn assertion failures into debugger break-points.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "throw_on_failure@D\n" 
+    "      Turn assertion failures into C++ exceptions for use by an external\n" 
+    "      test framework.\n" 
+    "  @G--" GTEST_FLAG_PREFIX_ 
+    "catch_exceptions=0@D\n" 
+    "      Do not report exceptions as test failures. Instead, allow them\n" 
+    "      to crash the program or throw a pop-up (on Windows).\n" 
+    "\n" 
+    "Except for @G--" GTEST_FLAG_PREFIX_ 
+    "list_tests@D, you can alternatively set " 
     "the corresponding\n"
-    "environment variable of a flag (all letters in upper-case). For example, "
-    "to\n"
-    "disable colored text output, you can either specify "
-    "@G--" GTEST_FLAG_PREFIX_
+    "environment variable of a flag (all letters in upper-case). For example, " 
+    "to\n" 
+    "disable colored text output, you can either specify " 
+    "@G--" GTEST_FLAG_PREFIX_ 
     "color=no@D or set\n"
-    "the @G" GTEST_FLAG_PREFIX_UPPER_
-    "COLOR@D environment variable to @Gno@D.\n"
-    "\n"
-    "For more information, please read the " GTEST_NAME_
-    " documentation at\n"
-    "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
-    "\n"
-    "(not one in your own code or tests), please report it to\n"
-    "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
-
-static bool ParseGoogleTestFlag(const char* const arg) {
+    "the @G" GTEST_FLAG_PREFIX_UPPER_ 
+    "COLOR@D environment variable to @Gno@D.\n" 
+    "\n" 
+    "For more information, please read the " GTEST_NAME_ 
+    " documentation at\n" 
+    "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ 
+    "\n" 
+    "(not one in your own code or tests), please report it to\n" 
+    "@G<" GTEST_DEV_EMAIL_ ">@D.\n"; 
+
+static bool ParseGoogleTestFlag(const char* const arg) { 
   return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
                        &GTEST_FLAG(also_run_disabled_tests)) ||
-         ParseBoolFlag(arg, kBreakOnFailureFlag,
-                       &GTEST_FLAG(break_on_failure)) ||
-         ParseBoolFlag(arg, kCatchExceptionsFlag,
-                       &GTEST_FLAG(catch_exceptions)) ||
-         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
-         ParseStringFlag(arg, kDeathTestStyleFlag,
-                         &GTEST_FLAG(death_test_style)) ||
-         ParseBoolFlag(arg, kDeathTestUseFork,
-                       &GTEST_FLAG(death_test_use_fork)) ||
-         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
-         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
-         ParseStringFlag(arg, kInternalRunDeathTestFlag,
-                         &GTEST_FLAG(internal_run_death_test)) ||
-         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
-         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
-         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
-         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
-         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
-         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
-         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
-         ParseInt32Flag(arg, kStackTraceDepthFlag,
-                        &GTEST_FLAG(stack_trace_depth)) ||
-         ParseStringFlag(arg, kStreamResultToFlag,
-                         &GTEST_FLAG(stream_result_to)) ||
-         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
+         ParseBoolFlag(arg, kBreakOnFailureFlag, 
+                       &GTEST_FLAG(break_on_failure)) || 
+         ParseBoolFlag(arg, kCatchExceptionsFlag, 
+                       &GTEST_FLAG(catch_exceptions)) || 
+         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) || 
+         ParseStringFlag(arg, kDeathTestStyleFlag, 
+                         &GTEST_FLAG(death_test_style)) || 
+         ParseBoolFlag(arg, kDeathTestUseFork, 
+                       &GTEST_FLAG(death_test_use_fork)) || 
+         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) || 
+         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) || 
+         ParseStringFlag(arg, kInternalRunDeathTestFlag, 
+                         &GTEST_FLAG(internal_run_death_test)) || 
+         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) || 
+         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) || 
+         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) || 
+         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) || 
+         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) || 
+         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) || 
+         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) || 
+         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) || 
+         ParseInt32Flag(arg, kStackTraceDepthFlag, 
+                        &GTEST_FLAG(stack_trace_depth)) || 
+         ParseStringFlag(arg, kStreamResultToFlag, 
+                         &GTEST_FLAG(stream_result_to)) || 
+         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure)); 
 }
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_
-static void LoadFlagsFromFile(const std::string& path) {
+static void LoadFlagsFromFile(const std::string& path) { 
   FILE* flagfile = posix::FOpen(path.c_str(), "r");
   if (!flagfile) {
-    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
-                      << "\"";
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile) 
+                      << "\""; 
   }
   std::string contents(ReadEntireFile(flagfile));
   posix::FClose(flagfile);
@@ -6606,17 +6606,17 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 // other parts of Google Test.
 void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
   ParseGoogleTestFlagsOnlyImpl(argc, argv);
-
-  // Fix the value of *_NSGetArgc() on macOS, but if and only if
-  // *_NSGetArgv() == argv
-  // Only applicable to char** version of argv
-#if GTEST_OS_MAC
-#ifndef GTEST_OS_IOS
-  if (*_NSGetArgv() == argv) {
-    *_NSGetArgc() = *argc;
-  }
-#endif
-#endif
+ 
+  // Fix the value of *_NSGetArgc() on macOS, but if and only if 
+  // *_NSGetArgv() == argv 
+  // Only applicable to char** version of argv 
+#if GTEST_OS_MAC 
+#ifndef GTEST_OS_IOS 
+  if (*_NSGetArgv() == argv) { 
+    *_NSGetArgc() = *argc; 
+  } 
+#endif 
+#endif 
 }
 void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
   ParseGoogleTestFlagsOnlyImpl(argc, argv);
@@ -6638,10 +6638,10 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
     g_argvs.push_back(StreamableToString(argv[i]));
   }
 
-#if GTEST_HAS_ABSL
-  absl::InitializeSymbolizer(g_argvs[0].c_str());
-#endif  // GTEST_HAS_ABSL
-
+#if GTEST_HAS_ABSL 
+  absl::InitializeSymbolizer(g_argvs[0].c_str()); 
+#endif  // GTEST_HAS_ABSL 
+ 
   ParseGoogleTestFlagsOnly(argc, argv);
   GetUnitTestImpl()->PostFlagParsingInit();
 }
@@ -6675,72 +6675,72 @@ void InitGoogleTest(int* argc, wchar_t** argv) {
 #endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 }
 
-// This overloaded version can be used on Arduino/embedded platforms where
-// there is no argc/argv.
-void InitGoogleTest() {
-  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
-  int argc = 1;
-  const auto arg0 = "dummy";
-  char* argv0 = const_cast<char*>(arg0);
-  char** argv = &argv0;
-
-#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
-#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-  internal::InitGoogleTestImpl(&argc, argv);
-#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
-}
-
-std::string TempDir() {
-#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
-  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
-#elif GTEST_OS_WINDOWS_MOBILE
-  return "\\temp\\";
-#elif GTEST_OS_WINDOWS
-  const char* temp_dir = internal::posix::GetEnv("TEMP");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "\\temp\\";
-  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
-    return temp_dir;
-  } else {
-    return std::string(temp_dir) + "\\";
-  }
-#elif GTEST_OS_LINUX_ANDROID
-  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "/data/local/tmp/";
-  } else {
-    return temp_dir;
-  }
-#elif GTEST_OS_LINUX
-  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
-  if (temp_dir == nullptr || temp_dir[0] == '\0') {
-    return "/tmp/";
-  } else {
-    return temp_dir;
-  }
-#else
-  return "/tmp/";
-#endif  // GTEST_OS_WINDOWS_MOBILE
-}
-
-// Class ScopedTrace
-
-// Pushes the given source file location and message onto a per-thread
-// trace stack maintained by Google Test.
-void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
-  internal::TraceInfo trace;
-  trace.file = file;
-  trace.line = line;
-  trace.message.swap(message);
-
-  UnitTest::GetInstance()->PushGTestTrace(trace);
-}
-
-// Pops the info pushed by the c'tor.
-ScopedTrace::~ScopedTrace()
-    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
-  UnitTest::GetInstance()->PopGTestTrace();
-}
-
+// This overloaded version can be used on Arduino/embedded platforms where 
+// there is no argc/argv. 
+void InitGoogleTest() { 
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments 
+  int argc = 1; 
+  const auto arg0 = "dummy"; 
+  char* argv0 = const_cast<char*>(arg0); 
+  char** argv = &argv0; 
+ 
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv); 
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 
+  internal::InitGoogleTestImpl(&argc, argv); 
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 
+} 
+ 
+std::string TempDir() { 
+#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) 
+  return GTEST_CUSTOM_TEMPDIR_FUNCTION_(); 
+#elif GTEST_OS_WINDOWS_MOBILE 
+  return "\\temp\\"; 
+#elif GTEST_OS_WINDOWS 
+  const char* temp_dir = internal::posix::GetEnv("TEMP"); 
+  if (temp_dir == nullptr || temp_dir[0] == '\0') { 
+    return "\\temp\\"; 
+  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') { 
+    return temp_dir; 
+  } else { 
+    return std::string(temp_dir) + "\\"; 
+  } 
+#elif GTEST_OS_LINUX_ANDROID 
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); 
+  if (temp_dir == nullptr || temp_dir[0] == '\0') { 
+    return "/data/local/tmp/"; 
+  } else { 
+    return temp_dir; 
+  } 
+#elif GTEST_OS_LINUX 
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR"); 
+  if (temp_dir == nullptr || temp_dir[0] == '\0') { 
+    return "/tmp/"; 
+  } else { 
+    return temp_dir; 
+  } 
+#else 
+  return "/tmp/"; 
+#endif  // GTEST_OS_WINDOWS_MOBILE 
+} 
+ 
+// Class ScopedTrace 
+ 
+// Pushes the given source file location and message onto a per-thread 
+// trace stack maintained by Google Test. 
+void ScopedTrace::PushTrace(const char* file, int line, std::string message) { 
+  internal::TraceInfo trace; 
+  trace.file = file; 
+  trace.line = line; 
+  trace.message.swap(message); 
+ 
+  UnitTest::GetInstance()->PushGTestTrace(trace); 
+} 
+ 
+// Pops the info pushed by the c'tor. 
+ScopedTrace::~ScopedTrace() 
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { 
+  UnitTest::GetInstance()->PopGTestTrace(); 
+} 
+ 
 }  // namespace testing
diff --git a/contrib/restricted/googletest/googletest/src/gtest_main.cc b/contrib/restricted/googletest/googletest/src/gtest_main.cc
index 46b27c3d7d..6ae0270785 100644
--- a/contrib/restricted/googletest/googletest/src/gtest_main.cc
+++ b/contrib/restricted/googletest/googletest/src/gtest_main.cc
@@ -27,28 +27,28 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <cstdio>
+#include <cstdio> 
 #include "gtest/gtest.h"
 
-#if GTEST_OS_ESP8266 || GTEST_OS_ESP32
-#if GTEST_OS_ESP8266
-extern "C" {
-#endif
-void setup() {
-  testing::InitGoogleTest();
-}
-
-void loop() { RUN_ALL_TESTS(); }
-
-#if GTEST_OS_ESP8266
-}
-#endif
-
-#else
-
+#if GTEST_OS_ESP8266 || GTEST_OS_ESP32 
+#if GTEST_OS_ESP8266 
+extern "C" { 
+#endif 
+void setup() { 
+  testing::InitGoogleTest(); 
+} 
+ 
+void loop() { RUN_ALL_TESTS(); } 
+ 
+#if GTEST_OS_ESP8266 
+} 
+#endif 
+ 
+#else 
+ 
 GTEST_API_ int main(int argc, char **argv) {
-  printf("Running main() from %s\n", __FILE__);
+  printf("Running main() from %s\n", __FILE__); 
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
-#endif
+#endif 
diff --git a/contrib/restricted/googletest/googletest/ya.make b/contrib/restricted/googletest/googletest/ya.make
index fd0915ff2c..bcdf762d6f 100644
--- a/contrib/restricted/googletest/googletest/ya.make
+++ b/contrib/restricted/googletest/googletest/ya.make
@@ -7,31 +7,31 @@ OWNER(
     g:cpp-contrib
 )
 
-LICENSE(BSD-3-Clause)
-
+LICENSE(BSD-3-Clause) 
+ 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-PEERDIR(
-    contrib/libs/re2
-)
-
+PEERDIR( 
+    contrib/libs/re2 
+) 
+ 
 ADDINCL(
-    GLOBAL contrib/restricted/googletest/googletest/include
-    contrib/restricted/googletest/googletest
+    GLOBAL contrib/restricted/googletest/googletest/include 
+    contrib/restricted/googletest/googletest 
 )
 
 NO_COMPILER_WARNINGS()
 
 NO_UTIL()
 
-CFLAGS(
+CFLAGS( 
     GLOBAL -DGTEST_HAS_ABSL=0
     GLOBAL -DGTEST_OS_FUCHSIA=0
     GLOBAL -DGTEST_HAS_STD_WSTRING=1
-)
-
+) 
+ 
 SRCS(
-    src/gtest-all.cc
+    src/gtest-all.cc 
 )
 
 END()
diff --git a/contrib/restricted/googletest/ya.make b/contrib/restricted/googletest/ya.make
index f563830db8..85bb21a707 100644
--- a/contrib/restricted/googletest/ya.make
+++ b/contrib/restricted/googletest/ya.make
@@ -1,14 +1,14 @@
 # Generated by devtools/yamaker from nixpkgs 21.11.
-
+ 
 OWNER(somov g:cpp-contrib)
-
+ 
 VERSION(1.11.0)
-
+ 
 ORIGINAL_SOURCE(https://github.com/google/googletest/archive/release-1.11.0.tar.gz)
 
-RECURSE(
-    googlemock
-    googlemock/gmock_main
-    googletest
-    googletest/gtest_main
-)
+RECURSE( 
+    googlemock 
+    googlemock/gmock_main 
+    googletest 
+    googletest/gtest_main 
+)